diff --git a/alib2algo/src/automaton/determinize/DeterminizeRHDPDAPart.cxx b/alib2algo/src/automaton/determinize/DeterminizeRHDPDAPart.cxx
index a7fed4fb757a635bfa4d1cef6135729cacbabf3c..7c2a496509ae853f1a5887294cea1696838a5651 100644
--- a/alib2algo/src/automaton/determinize/DeterminizeRHDPDAPart.cxx
+++ b/alib2algo/src/automaton/determinize/DeterminizeRHDPDAPart.cxx
@@ -15,7 +15,7 @@ namespace automaton {
namespace determinize {
-void addRetTransition(const DefaultStateType& from, const std::variant<DefaultEpsilonType, DefaultSymbolType>& input, const DefaultSymbolType& dvpdaSymbol, const DefaultStateType& to, automaton::RealTimeHeightDeterministicDPDA < > & deterministic) {
+void addRetTransition(const DefaultStateType& from, const ext::variant<DefaultEpsilonType, DefaultSymbolType>& input, const DefaultSymbolType& dvpdaSymbol, const DefaultStateType& to, automaton::RealTimeHeightDeterministicDPDA < > & deterministic) {
deterministic.addState(from);
deterministic.addState(to);
deterministic.addPushdownStoreSymbol(dvpdaSymbol);
@@ -23,7 +23,7 @@ void addRetTransition(const DefaultStateType& from, const std::variant<DefaultEp
deterministic.addReturnTransition(from, input, dvpdaSymbol, to);
}
-void retInitial(const DefaultStateType& state, const DefaultSymbolType& pdaSymbol, const std::variant<DefaultEpsilonType, DefaultSymbolType>& input, const automaton::RealTimeHeightDeterministicNPDA < > & nondeterministic, automaton::RealTimeHeightDeterministicDPDA < > & deterministic, std::map<std::tuple<DefaultStateType, std::variant<DefaultEpsilonType, DefaultSymbolType>, DefaultSymbolType>, DefaultStateType>& rubbishReturnTransitions) {
+void retInitial(const DefaultStateType& state, const DefaultSymbolType& pdaSymbol, const ext::variant<DefaultEpsilonType, DefaultSymbolType>& input, const automaton::RealTimeHeightDeterministicNPDA < > & nondeterministic, automaton::RealTimeHeightDeterministicDPDA < > & deterministic, std::map<std::tuple<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>, DefaultSymbolType>, DefaultStateType>& rubbishReturnTransitions) {
const std::set<std::pair<DefaultStateType, DefaultStateType>> & S = unpackFromStateLabel(state);
std::set<std::pair<DefaultStateType, DefaultStateType>> S1;
@@ -46,16 +46,16 @@ void retInitial(const DefaultStateType& state, const DefaultSymbolType& pdaSymbo
bool S1Empty = S1.empty();
DefaultStateType to(packToStateLabel(std::move(S1)));
if(S1Empty) {
- std::tuple<DefaultStateType, std::variant<DefaultEpsilonType, DefaultSymbolType>, DefaultSymbolType> key(state, input, pdaSymbol);
+ std::tuple<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>, DefaultSymbolType> key(state, input, pdaSymbol);
rubbishReturnTransitions.insert(std::make_pair(key, to));
} else {
addRetTransition(state, input, pdaSymbol, to, deterministic);
}
}
-void ret(const DefaultStateType& state, const DefaultSymbolType& pdaSymbol, const std::variant<DefaultEpsilonType, DefaultSymbolType>& input, const automaton::RealTimeHeightDeterministicNPDA < > & nondeterministic, automaton::RealTimeHeightDeterministicDPDA < > & deterministic, std::map<std::tuple<DefaultStateType, std::variant<DefaultEpsilonType, DefaultSymbolType>, DefaultSymbolType>, DefaultStateType>& rubbishReturnTransitions) {
+void ret(const DefaultStateType& state, const DefaultSymbolType& pdaSymbol, const ext::variant<DefaultEpsilonType, DefaultSymbolType>& input, const automaton::RealTimeHeightDeterministicNPDA < > & nondeterministic, automaton::RealTimeHeightDeterministicDPDA < > & deterministic, std::map<std::tuple<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>, DefaultSymbolType>, DefaultStateType>& rubbishReturnTransitions) {
const std::set<std::pair<DefaultStateType, DefaultStateType>> & S = unpackFromStateLabel(state);
- const std::pair<DefaultStateType, std::variant<DefaultEpsilonType, DefaultSymbolType>> & pdaSymbolUnpack = unpackFromDRHDPDAStackSymbol(pdaSymbol);
+ const std::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>> & pdaSymbolUnpack = unpackFromDRHDPDAStackSymbol(pdaSymbol);
const std::set<std::pair<DefaultStateType, DefaultStateType>>& S1 = unpackFromStateLabel ( pdaSymbolUnpack.first );
std::set<std::pair<DefaultStateType, DefaultStateType>> update;
@@ -103,14 +103,14 @@ void ret(const DefaultStateType& state, const DefaultSymbolType& pdaSymbol, cons
bool S2Empty = S2.empty();
DefaultStateType to(packToStateLabel(std::move(S2)));
if(S2Empty) {
- std::tuple<DefaultStateType, std::variant<DefaultEpsilonType, DefaultSymbolType>, DefaultSymbolType> key(state, input, pdaSymbol);
+ std::tuple<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>, DefaultSymbolType> key(state, input, pdaSymbol);
rubbishReturnTransitions.insert(std::make_pair(key, to));
} else {
addRetTransition(state, input, pdaSymbol, to, deterministic);
}
}
-void addCallTransition(const DefaultStateType& from, const std::variant<DefaultEpsilonType, DefaultSymbolType>& input, const DefaultStateType& to, const DefaultSymbolType& dvpdaSymbol, automaton::RealTimeHeightDeterministicDPDA < > & deterministic) {
+void addCallTransition(const DefaultStateType& from, const ext::variant<DefaultEpsilonType, DefaultSymbolType>& input, const DefaultStateType& to, const DefaultSymbolType& dvpdaSymbol, automaton::RealTimeHeightDeterministicDPDA < > & deterministic) {
deterministic.addState(from);
deterministic.addState(to);
deterministic.addPushdownStoreSymbol(dvpdaSymbol);
@@ -118,7 +118,7 @@ void addCallTransition(const DefaultStateType& from, const std::variant<DefaultE
deterministic.addCallTransition(from, input, to, dvpdaSymbol);
}
-void call(const DefaultStateType& state, const std::variant<DefaultEpsilonType, DefaultSymbolType>& input, const automaton::RealTimeHeightDeterministicNPDA < > & nondeterministic, automaton::RealTimeHeightDeterministicDPDA < > & deterministic, std::map<std::pair<DefaultStateType, std::variant<DefaultEpsilonType, DefaultSymbolType>>, std::pair<DefaultStateType, DefaultSymbolType> >& rubbishCallTransitions) {
+void call(const DefaultStateType& state, const ext::variant<DefaultEpsilonType, DefaultSymbolType>& input, const automaton::RealTimeHeightDeterministicNPDA < > & nondeterministic, automaton::RealTimeHeightDeterministicDPDA < > & deterministic, std::map<std::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>>, std::pair<DefaultStateType, DefaultSymbolType> >& rubbishCallTransitions) {
const std::set<std::pair<DefaultStateType, DefaultStateType>> & S = unpackFromStateLabel(state);
std::set<DefaultStateType> R = retrieveDSubSet(S);
@@ -147,14 +147,14 @@ void call(const DefaultStateType& state, const std::variant<DefaultEpsilonType,
}
}
-void addLocalTransition(const DefaultStateType& from, const std::variant<DefaultEpsilonType, DefaultSymbolType>& input, const DefaultStateType& to, automaton::RealTimeHeightDeterministicDPDA < > & deterministic) {
+void addLocalTransition(const DefaultStateType& from, const ext::variant<DefaultEpsilonType, DefaultSymbolType>& input, const DefaultStateType& to, automaton::RealTimeHeightDeterministicDPDA < > & deterministic) {
deterministic.addState(from);
deterministic.addState(to);
deterministic.addLocalTransition(from, input, to);
}
-void local(const DefaultStateType& state, const std::variant<DefaultEpsilonType, DefaultSymbolType>& input, const automaton::RealTimeHeightDeterministicNPDA < > & nondeterministic, automaton::RealTimeHeightDeterministicDPDA < > & deterministic, std::map<std::pair<DefaultStateType, std::variant<DefaultEpsilonType, DefaultSymbolType>>, DefaultStateType>& rubbishLocalTransitions ) {
+void local(const DefaultStateType& state, const ext::variant<DefaultEpsilonType, DefaultSymbolType>& input, const automaton::RealTimeHeightDeterministicNPDA < > & nondeterministic, automaton::RealTimeHeightDeterministicDPDA < > & deterministic, std::map<std::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>>, DefaultStateType>& rubbishLocalTransitions ) {
const std::set<std::pair<DefaultStateType, DefaultStateType>> & S = unpackFromStateLabel(state);
std::set<std::pair<DefaultStateType, DefaultStateType>> S1;
@@ -182,10 +182,10 @@ void local(const DefaultStateType& state, const std::variant<DefaultEpsilonType,
}
}
-std::tuple<std::set<std::variant<DefaultEpsilonType, DefaultSymbolType>>, std::set<std::variant<DefaultEpsilonType, DefaultSymbolType>>, std::set<std::variant<DefaultEpsilonType, DefaultSymbolType>>> getLocalCallRetPartitioning(const automaton::RealTimeHeightDeterministicNPDA < > & n, const DefaultStateType& state) {
- std::set<std::variant<DefaultEpsilonType, DefaultSymbolType>> local;
- std::set<std::variant<DefaultEpsilonType, DefaultSymbolType>> call;
- std::set<std::variant<DefaultEpsilonType, DefaultSymbolType>> ret;
+std::tuple<std::set<ext::variant<DefaultEpsilonType, DefaultSymbolType>>, std::set<ext::variant<DefaultEpsilonType, DefaultSymbolType>>, std::set<ext::variant<DefaultEpsilonType, DefaultSymbolType>>> getLocalCallRetPartitioning(const automaton::RealTimeHeightDeterministicNPDA < > & n, const DefaultStateType& state) {
+ std::set<ext::variant<DefaultEpsilonType, DefaultSymbolType>> local;
+ std::set<ext::variant<DefaultEpsilonType, DefaultSymbolType>> call;
+ std::set<ext::variant<DefaultEpsilonType, DefaultSymbolType>> ret;
const std::set<DefaultStateType> dSubSet = retrieveDSubSet(unpackFromStateLabel(state));
@@ -214,9 +214,9 @@ automaton::RealTimeHeightDeterministicDPDA < > Determinize::determinize(const au
d.setInputAlphabet(n.getInputAlphabet());
std::set<DefaultStateType> rubbishStates = {DefaultStateType(packToStateLabel({}))};
- std::map<std::tuple<DefaultStateType, std::variant<DefaultEpsilonType, DefaultSymbolType>, DefaultSymbolType>, DefaultStateType> rubbishReturnTransitions;
- std::map<std::pair<DefaultStateType, std::variant<DefaultEpsilonType, DefaultSymbolType>>, std::pair<DefaultStateType, DefaultSymbolType> > rubbishCallTransitions;
- std::map<std::pair<DefaultStateType, std::variant<DefaultEpsilonType, DefaultSymbolType>>, DefaultStateType> rubbishLocalTransitions;
+ std::map<std::tuple<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>, DefaultSymbolType>, DefaultStateType> rubbishReturnTransitions;
+ std::map<std::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>>, std::pair<DefaultStateType, DefaultSymbolType> > rubbishCallTransitions;
+ std::map<std::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>>, DefaultStateType> rubbishLocalTransitions;
for(;;) {
std::set<std::pair<DefaultStateType, DefaultSymbolType>> stateSymbols = existsDirtyStateSymbol(d, rubbishStates, rubbishCallTransitions, rubbishReturnTransitions, n);
@@ -228,9 +228,9 @@ automaton::RealTimeHeightDeterministicDPDA < > Determinize::determinize(const au
if ( common::GlobalData::verbose )
std::clog << "Dirty state symbol: " << stateSymbol << std::endl;
- std::tuple<std::set<std::variant<DefaultEpsilonType, DefaultSymbolType>>, std::set<std::variant<DefaultEpsilonType, DefaultSymbolType>>, std::set<std::variant<DefaultEpsilonType, DefaultSymbolType>>> partitioning = getLocalCallRetPartitioning(n, stateSymbol.first);
+ std::tuple<std::set<ext::variant<DefaultEpsilonType, DefaultSymbolType>>, std::set<ext::variant<DefaultEpsilonType, DefaultSymbolType>>, std::set<ext::variant<DefaultEpsilonType, DefaultSymbolType>>> partitioning = getLocalCallRetPartitioning(n, stateSymbol.first);
- std::set<std::variant<DefaultEpsilonType, DefaultSymbolType>>& retPart = std::get<2>(partitioning);
+ std::set<ext::variant<DefaultEpsilonType, DefaultSymbolType>>& retPart = std::get<2>(partitioning);
for(const auto& symbol : retPart) {
if(stateSymbol.second == d.getBottomOfTheStackSymbol()) {
@@ -244,10 +244,10 @@ automaton::RealTimeHeightDeterministicDPDA < > Determinize::determinize(const au
for(const auto& state : states) {
if ( common::GlobalData::verbose )
std::clog << "Dirty state: " << state << std::endl;
- std::tuple<std::set<std::variant<DefaultEpsilonType, DefaultSymbolType>>, std::set<std::variant<DefaultEpsilonType, DefaultSymbolType>>, std::set<std::variant<DefaultEpsilonType, DefaultSymbolType>>> partitioning = getLocalCallRetPartitioning(n, state);
+ std::tuple<std::set<ext::variant<DefaultEpsilonType, DefaultSymbolType>>, std::set<ext::variant<DefaultEpsilonType, DefaultSymbolType>>, std::set<ext::variant<DefaultEpsilonType, DefaultSymbolType>>> partitioning = getLocalCallRetPartitioning(n, state);
- std::set<std::variant<DefaultEpsilonType, DefaultSymbolType>>& localPart = std::get<0>(partitioning);
- std::set<std::variant<DefaultEpsilonType, DefaultSymbolType>>& callPart = std::get<1>(partitioning);
+ std::set<ext::variant<DefaultEpsilonType, DefaultSymbolType>>& localPart = std::get<0>(partitioning);
+ std::set<ext::variant<DefaultEpsilonType, DefaultSymbolType>>& callPart = std::get<1>(partitioning);
for(const auto& symbol : localPart) {
local(state, symbol, n, d, rubbishLocalTransitions);
diff --git a/alib2algo/src/automaton/determinize/common/RHDPDACommon.cpp b/alib2algo/src/automaton/determinize/common/RHDPDACommon.cpp
index 990a6433afba3a379eb8bf3ff7385c13281d752b..4949f25245c27b9eafbf72b033ea6221c6119b25 100644
--- a/alib2algo/src/automaton/determinize/common/RHDPDACommon.cpp
+++ b/alib2algo/src/automaton/determinize/common/RHDPDACommon.cpp
@@ -28,12 +28,12 @@ const std::pair<DefaultStateType, DefaultSymbolType> & unpackFromDVPAStackSymbol
return static_cast < const alib::AnyObject < std::pair<DefaultStateType, DefaultSymbolType> > & > ( symbol.getData ( ) ).getData ( );
}
-DefaultSymbolType packToStackSymbolLabel(std::pair<DefaultStateType, std::variant<DefaultEpsilonType, DefaultSymbolType>>&& data) {
- return DefaultSymbolType ( alib::AnyObject < std::pair<DefaultStateType, std::variant<DefaultEpsilonType, DefaultSymbolType>> > ( std::move ( data ) ) );
+DefaultSymbolType packToStackSymbolLabel(std::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>>&& data) {
+ return DefaultSymbolType ( alib::AnyObject < std::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>> > ( std::move ( data ) ) );
}
-const std::pair<DefaultStateType, std::variant<DefaultEpsilonType, DefaultSymbolType>> & unpackFromDRHDPDAStackSymbol(const DefaultSymbolType& symbol) {
- return static_cast < const alib::AnyObject < std::pair<DefaultStateType, std::variant<DefaultEpsilonType, DefaultSymbolType>> > & > ( symbol.getData ( ) ).getData ( );
+const std::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>> & unpackFromDRHDPDAStackSymbol(const DefaultSymbolType& symbol) {
+ return static_cast < const alib::AnyObject < std::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>> > & > ( symbol.getData ( ) ).getData ( );
}
std::set<DefaultStateType> retrieveDSubSet(const std::set<std::pair<DefaultStateType, DefaultStateType>>& localOperation) {
@@ -105,7 +105,7 @@ std::set<DefaultStateType> existsDirtyState(const T& d, const std::set<DefaultSt
}
template std::set<DefaultStateType> existsDirtyState(const automaton::VisiblyPushdownDPDA < > & d, const std::set<DefaultStateType>& rubbishStates, const std::map<std::pair<DefaultStateType, DefaultSymbolType>, std::pair<DefaultStateType, DefaultSymbolType> >& rubbishCallTransitions, const std::map<std::pair<DefaultStateType, DefaultSymbolType>, DefaultStateType>& rubbishLocalTransitions, const automaton::VisiblyPushdownNPDA < > & n);
-template std::set<DefaultStateType> existsDirtyState(const automaton::RealTimeHeightDeterministicDPDA < > & d, const std::set<DefaultStateType>& rubbishStates, const std::map<std::pair<DefaultStateType, std::variant<DefaultEpsilonType, DefaultSymbolType>>, std::pair<DefaultStateType, DefaultSymbolType> >& rubbishCallTransitions, const std::map<std::pair<DefaultStateType, std::variant<DefaultEpsilonType, DefaultSymbolType>>, DefaultStateType>& rubbishLocalTransitions, const automaton::RealTimeHeightDeterministicNPDA < > & n);
+template std::set<DefaultStateType> existsDirtyState(const automaton::RealTimeHeightDeterministicDPDA < > & d, const std::set<DefaultStateType>& rubbishStates, const std::map<std::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>>, std::pair<DefaultStateType, DefaultSymbolType> >& rubbishCallTransitions, const std::map<std::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>>, DefaultStateType>& rubbishLocalTransitions, const automaton::RealTimeHeightDeterministicNPDA < > & n);
void localClosure(std::set<DefaultStateType>& states, const std::set<DefaultStateType>& oldStates, const automaton::RealTimeHeightDeterministicDPDA < > & d) {
std::set<DefaultStateType> newStates;
@@ -226,7 +226,7 @@ std::set<std::pair<DefaultStateType, DefaultSymbolType>> existsDirtyStateSymbol(
}
template std::set<std::pair<DefaultStateType, DefaultSymbolType>> existsDirtyStateSymbol(const automaton::VisiblyPushdownDPDA < > & d, const std::set<DefaultStateType>& rubbishStates, const std::map<std::pair<DefaultStateType, DefaultSymbolType>, std::pair<DefaultStateType, DefaultSymbolType> >& rubbishCallTransitions, const std::map<std::tuple<DefaultStateType, DefaultSymbolType, DefaultSymbolType>, DefaultStateType>& rubbishReturnTransitions, const automaton::VisiblyPushdownNPDA < > & n);
-template std::set<std::pair<DefaultStateType, DefaultSymbolType>> existsDirtyStateSymbol(const automaton::RealTimeHeightDeterministicDPDA < > & d, const std::set<DefaultStateType>& rubbishStates, const std::map<std::pair<DefaultStateType, std::variant<DefaultEpsilonType, DefaultSymbolType>>, std::pair<DefaultStateType, DefaultSymbolType> >& rubbishCallTransitions, const std::map<std::tuple<DefaultStateType, std::variant<DefaultEpsilonType, DefaultSymbolType>, DefaultSymbolType>, DefaultStateType>& rubbishReturnTransitions, const automaton::RealTimeHeightDeterministicNPDA < > & n);
+template std::set<std::pair<DefaultStateType, DefaultSymbolType>> existsDirtyStateSymbol(const automaton::RealTimeHeightDeterministicDPDA < > & d, const std::set<DefaultStateType>& rubbishStates, const std::map<std::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>>, std::pair<DefaultStateType, DefaultSymbolType> >& rubbishCallTransitions, const std::map<std::tuple<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>, DefaultSymbolType>, DefaultStateType>& rubbishReturnTransitions, const automaton::RealTimeHeightDeterministicNPDA < > & n);
} /* namespace automaton */
diff --git a/alib2algo/src/automaton/determinize/common/RHDPDACommon.h b/alib2algo/src/automaton/determinize/common/RHDPDACommon.h
index ffe0fa28c7aaf18d7478aa576916daea26f543d8..c33e436307e2f6771063bb5450ba931e54acd68b 100644
--- a/alib2algo/src/automaton/determinize/common/RHDPDACommon.h
+++ b/alib2algo/src/automaton/determinize/common/RHDPDACommon.h
@@ -22,9 +22,9 @@ DefaultSymbolType packToStackSymbolLabel(std::pair<DefaultStateType, DefaultSymb
const std::pair<DefaultStateType, DefaultSymbolType> & unpackFromDVPAStackSymbol(const DefaultSymbolType& symbol);
-DefaultSymbolType packToStackSymbolLabel(std::pair<DefaultStateType, std::variant<DefaultEpsilonType, DefaultSymbolType>>&& data);
+DefaultSymbolType packToStackSymbolLabel(std::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>>&& data);
-const std::pair<DefaultStateType, std::variant<DefaultEpsilonType, DefaultSymbolType>> & unpackFromDRHDPDAStackSymbol(const DefaultSymbolType& symbol);
+const std::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>> & unpackFromDRHDPDAStackSymbol(const DefaultSymbolType& symbol);
std::set<DefaultStateType> retrieveDSubSet(const std::set<std::pair<DefaultStateType, DefaultStateType>>& localOperation);
diff --git a/alib2algo/src/automaton/generate/RandomizeAutomaton.h b/alib2algo/src/automaton/generate/RandomizeAutomaton.h
index bdb0eeec0fb4fe195499617d83eb16b7f1299b6d..b7267a607a718647446c3535dca762ac5a4f4ae7 100644
--- a/alib2algo/src/automaton/generate/RandomizeAutomaton.h
+++ b/alib2algo/src/automaton/generate/RandomizeAutomaton.h
@@ -107,7 +107,7 @@ automaton::EpsilonNFA < SymbolType, EpsilonType, StateType > RandomizeAutomaton:
for ( const StateType & finalState : origFSM.getFinalStates ( ) )
res.addFinalState ( statePermutationMap.find ( finalState )->second );
- for ( const std::pair < std::pair < StateType, std::variant < EpsilonType, SymbolType > >, std::set < SymbolType > > & transition : origFSM.getTransitions ( ) )
+ for ( const std::pair < std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, std::set < SymbolType > > & transition : origFSM.getTransitions ( ) )
for ( const StateType & target : transition.second )
res.addTransition ( statePermutationMap.find ( transition.first.first )->second, transition.first.second, statePermutationMap.find ( target )->second );
diff --git a/alib2algo/src/automaton/properties/EpsilonClosure.h b/alib2algo/src/automaton/properties/EpsilonClosure.h
index 380d314bc2886d1af430f6935af9572fbc88a562..0b639089c900bd29725a5609c4e7d69f4531726d 100644
--- a/alib2algo/src/automaton/properties/EpsilonClosure.h
+++ b/alib2algo/src/automaton/properties/EpsilonClosure.h
@@ -70,7 +70,7 @@ std::set<StateType> EpsilonClosure::epsilonClosure( const automaton::EpsilonNFA
visited[ p ] = true;
closure.insert( p );
- auto tos = fsm.getTransitions( ).find(std::make_pair ( p, std::variant < EpsilonType, SymbolType >::template from < EpsilonType > ( ) ) );
+ auto tos = fsm.getTransitions( ).find(std::make_pair ( p, ext::variant < EpsilonType, SymbolType >::template from < EpsilonType > ( ) ) );
if(tos == fsm.getTransitions().end()) continue;
for( const auto & to : tos->second )
diff --git a/alib2algo/src/automaton/simplify/Normalize.h b/alib2algo/src/automaton/simplify/Normalize.h
index 29a678f5fbf8b7ba1ebb0dc9805ab7906222110c..c67f3b6596d07492ab80f6b29945f6bb8339f2fb 100644
--- a/alib2algo/src/automaton/simplify/Normalize.h
+++ b/alib2algo/src/automaton/simplify/Normalize.h
@@ -91,10 +91,10 @@ automaton::DPDA < InputSymbolType, EpsilonType, unsigned, unsigned > Normalize::
StateType current = std::move ( processingData.front() );
processingData.pop_front();
- std::map < std::pair < std::variant < EpsilonType, InputSymbolType >, std::vector < unsigned > >, std::pair < StateType, std::vector < PushdownStoreSymbolType > > > transform;
+ std::map < std::pair < ext::variant < EpsilonType, InputSymbolType >, std::vector < unsigned > >, std::pair < StateType, std::vector < PushdownStoreSymbolType > > > transform;
bool stateFinished = true;
// For each transition from state current
- for ( const std::pair < const std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::pair < StateType, std::vector < PushdownStoreSymbolType > > > & iter : pda.getTransitionsFromState(current)) {
+ for ( const std::pair < const std::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::pair < StateType, std::vector < PushdownStoreSymbolType > > > & iter : pda.getTransitionsFromState(current)) {
// look whether all poped symbols are already transformed
if(std::all_of(std::get<2>(iter.first).begin(), std::get<2>(iter.first).end(), [&](const PushdownStoreSymbolType& symbol) { return normalizationDataSymbol.find(symbol) != normalizationDataSymbol.end(); })) {
std::vector < unsigned > transformedSymbols;
diff --git a/alib2algo/src/grammar/generate/CockeYoungerKasami.h b/alib2algo/src/grammar/generate/CockeYoungerKasami.h
index 371b79a401635acaf60f5abf7c8b64769f0dcfa8..b3bdb7bba55b8c7440f0d510efcf9d716b137df1 100644
--- a/alib2algo/src/grammar/generate/CockeYoungerKasami.h
+++ b/alib2algo/src/grammar/generate/CockeYoungerKasami.h
@@ -44,10 +44,10 @@ bool CockeYoungerKasami::generate ( const grammar::CNF < SymbolType > & grammar,
data[i].resize ( stringSize - i );
for ( unsigned i = 0; i < stringSize; i++ )
- for ( const std::pair < const SymbolType, std::set < std::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > rule : grammar.getRules ( ) ) {
+ for ( const std::pair < const SymbolType, std::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > rule : grammar.getRules ( ) ) {
const SymbolType & lhs = rule.first;
- for ( const std::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs : rule.second )
+ for ( const ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs : rule.second )
if ( rhs.template is < SymbolType > ( ) && ( rhs.template get < SymbolType > ( ) == string.getContent ( )[i] ) )
data[0][i].insert ( lhs );
@@ -64,10 +64,10 @@ bool CockeYoungerKasami::generate ( const grammar::CNF < SymbolType > & grammar,
for ( const SymbolType & verticalElement : vertical ) {
for ( const SymbolType & diagonalElement : diagonal )
- for ( const std::pair < const SymbolType, std::set < std::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > rule : grammar.getRules ( ) ) {
+ for ( const std::pair < const SymbolType, std::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > rule : grammar.getRules ( ) ) {
const SymbolType & lhs = rule.first;
- for ( const std::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs : rule.second )
+ for ( const ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs : rule.second )
if ( rhs.template is < std::pair < SymbolType, SymbolType > > ( ) ) {
const std::pair < SymbolType, SymbolType > rhsp = rhs.template get < std::pair < SymbolType, SymbolType > > ( );
diff --git a/alib2algo/src/grammar/generate/RandomizeGrammar.h b/alib2algo/src/grammar/generate/RandomizeGrammar.h
index 7b42a8765e7b14c1437c9edd0bfef1ae875cdeec..fc81ebced36a16d19e983c11dfeace34ffc70444 100644
--- a/alib2algo/src/grammar/generate/RandomizeGrammar.h
+++ b/alib2algo/src/grammar/generate/RandomizeGrammar.h
@@ -49,8 +49,8 @@ grammar::LeftRG < SymbolType > RandomizeGrammar::randomize ( const grammar::Left
res.setNonterminalAlphabet ( gram.getNonterminalAlphabet ( ) );
res.setTerminalAlphabet ( gram.getTerminalAlphabet ( ) );
- for ( const std::pair < SymbolType, std::set < std::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & rule : gram.getRules ( ) )
- for ( const std::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rhs : rule.second )
+ for ( const std::pair < SymbolType, std::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & rule : gram.getRules ( ) )
+ for ( const ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rhs : rule.second )
if ( rhs.template is < SymbolType > ( ) )
res.addRule ( symbolPermutationMap.find ( rule.first )->second, rhs );
else
@@ -68,8 +68,8 @@ grammar::LeftLG < SymbolType > RandomizeGrammar::randomize ( const grammar::Left
res.setNonterminalAlphabet ( gram.getNonterminalAlphabet ( ) );
res.setTerminalAlphabet ( gram.getTerminalAlphabet ( ) );
- for ( const std::pair < SymbolType, std::set < std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > > > & rule : gram.getRules ( ) )
- for ( const std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > & rhs : rule.second )
+ for ( const std::pair < SymbolType, std::set < ext::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > > > & rule : gram.getRules ( ) )
+ for ( const ext::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > & rhs : rule.second )
if ( rhs.template is < std::vector < SymbolType > > ( ) )
res.addRule ( symbolPermutationMap.find ( rule.first )->second, rhs );
else
@@ -87,8 +87,8 @@ grammar::RightRG < SymbolType > RandomizeGrammar::randomize ( const grammar::Rig
res.setNonterminalAlphabet ( gram.getNonterminalAlphabet ( ) );
res.setTerminalAlphabet ( gram.getTerminalAlphabet ( ) );
- for ( const std::pair < SymbolType, std::set < std::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & rule : gram.getRules ( ) )
- for ( const std::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rhs : rule.second )
+ for ( const std::pair < SymbolType, std::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & rule : gram.getRules ( ) )
+ for ( const ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rhs : rule.second )
if ( rhs.template is < SymbolType > ( ) )
res.addRule ( symbolPermutationMap.find ( rule.first )->second, rhs );
else
@@ -106,8 +106,8 @@ grammar::RightLG < SymbolType > RandomizeGrammar::randomize ( const grammar::Rig
res.setNonterminalAlphabet ( gram.getNonterminalAlphabet ( ) );
res.setTerminalAlphabet ( gram.getTerminalAlphabet ( ) );
- for ( const std::pair < SymbolType, std::set < std::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > > > & rule : gram.getRules ( ) )
- for ( const std::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > & rhs : rule.second )
+ for ( const std::pair < SymbolType, std::set < ext::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > > > & rule : gram.getRules ( ) )
+ for ( const ext::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > & rhs : rule.second )
if ( rhs.template is < std::vector < SymbolType > > ( ) )
res.addRule ( symbolPermutationMap.find ( rule.first )->second, rhs );
else
diff --git a/alib2algo/src/stringology/indexing/SuffixTrieNaive.h b/alib2algo/src/stringology/indexing/SuffixTrieNaive.h
index 224936b373c903b2395cfbeb9779bf5e1c6fae90..003379d46186395eb8b4ec55e22bd9ca0b436912 100644
--- a/alib2algo/src/stringology/indexing/SuffixTrieNaive.h
+++ b/alib2algo/src/stringology/indexing/SuffixTrieNaive.h
@@ -39,19 +39,19 @@ public:
template < class SymbolType >
indexes::stringology::SuffixTrie < SymbolType > SuffixTrieNaive::construct ( const string::LinearString < SymbolType > & w ) {
- std::trie < SymbolType, std::variant < void, unsigned > > trie ( std::variant < void, unsigned > ( ( unsigned ) w.getContent ( ).size ( ) ) );
+ std::trie < SymbolType, ext::variant < void, unsigned > > trie ( ext::variant < void, unsigned > ( ( unsigned ) w.getContent ( ).size ( ) ) );
for ( unsigned i = w.getContent ( ).size ( ); i > 0; i-- ) {
unsigned k = i - 1;
- std::trie < SymbolType, std::variant < void, unsigned > > * n = & trie;
+ std::trie < SymbolType, ext::variant < void, unsigned > > * n = & trie;
// inlined slow_find_one from MI-EVY lectures
while ( n->getChildren ( ).count ( w.getContent ( )[k] ) )
n = & n->getChildren ( ).find ( w.getContent ( )[k++] )->second;
for ( ; k < w.getContent ( ).size ( ); k++ ) {
- std::variant < void, unsigned > node = k + 1 < w.getContent ( ).size ( ) ? std::variant < void, unsigned >::from < void > ( ) : std::variant < void, unsigned > ( i - 1 );
- n = & n->getChildren ( ).insert ( std::make_pair ( w.getContent ( )[k], std::trie < SymbolType, std::variant < void, unsigned > > ( node ) ) ).first->second;
+ ext::variant < void, unsigned > node = k + 1 < w.getContent ( ).size ( ) ? ext::variant < void, unsigned >::from < void > ( ) : ext::variant < void, unsigned > ( i - 1 );
+ n = & n->getChildren ( ).insert ( std::make_pair ( w.getContent ( )[k], std::trie < SymbolType, ext::variant < void, unsigned > > ( node ) ) ).first->second;
}
}
diff --git a/alib2algo/src/stringology/query/SuffixTrieFactors.h b/alib2algo/src/stringology/query/SuffixTrieFactors.h
index f13fa3f544c6bece86885a5bfcebc70399925f01..b9e8bb15a94199d6253a2c05ddb4cf19f33c4a17 100644
--- a/alib2algo/src/stringology/query/SuffixTrieFactors.h
+++ b/alib2algo/src/stringology/query/SuffixTrieFactors.h
@@ -25,11 +25,11 @@ namespace query {
class SuffixTrieFactors : public alib::SingleDispatchFirstStaticParam < SuffixTrieFactors, std::set < unsigned >, const indexes::stringology::SuffixTrie < DefaultSymbolType > &, const string::StringBase & > {
template < class SymbolType >
- static void accumulateResult ( const std::trie < SymbolType, std::variant < void, unsigned > > & trie, std::set < unsigned > & res ) {
+ static void accumulateResult ( const std::trie < SymbolType, ext::variant < void, unsigned > > & trie, std::set < unsigned > & res ) {
if ( trie.getData ( ).template is < unsigned > ( ) )
res.insert ( trie.getData ( ).template get < unsigned > ( ) );
- for ( const std::pair < SymbolType, std::trie < SymbolType, std::variant < void, unsigned > > > & child : trie.getChildren ( ) ) {
+ for ( const std::pair < SymbolType, std::trie < SymbolType, ext::variant < void, unsigned > > > & child : trie.getChildren ( ) ) {
accumulateResult ( child.second, res );
}
}
@@ -50,7 +50,7 @@ public:
template < class SymbolType >
std::set < unsigned > SuffixTrieFactors::query ( const indexes::stringology::SuffixTrie < SymbolType > & suffixTrie, const string::LinearString < SymbolType > & string ) {
- const std::trie < SymbolType, std::variant < void, unsigned > > * node = & suffixTrie.getRoot ( );
+ const std::trie < SymbolType, ext::variant < void, unsigned > > * node = & suffixTrie.getRoot ( );
for ( const SymbolType & symbol : string.getContent ( ) ) {
auto iter = node->getChildren ( ).find ( symbol );
if ( iter == node->getChildren ( ).end ( ) ) {
diff --git a/alib2algo_experimental/src/grammar/parsing/DeterministicLL1Grammar.cpp b/alib2algo_experimental/src/grammar/parsing/DeterministicLL1Grammar.cpp
index eefcd92fdbe050a9c1e6c46143428e023419d576..794bc2602768fe239ffb6ecfe7cfac625f2f6df5 100644
--- a/alib2algo_experimental/src/grammar/parsing/DeterministicLL1Grammar.cpp
+++ b/alib2algo_experimental/src/grammar/parsing/DeterministicLL1Grammar.cpp
@@ -31,16 +31,16 @@ grammar::CFG < > DeterministicLL1Grammar::convert ( const grammar::CFG < > & par
grammar::CFG < > grammar = param;
while ( true ) {
- std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > > parseTable = LL1ParseTable::parseTable ( grammar );
+ std::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > > parseTable = LL1ParseTable::parseTable ( grammar );
bool deterministic = true;
- for ( const std::pair < const std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > > & elem : parseTable )
+ for ( const std::pair < const std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > > & elem : parseTable )
if ( elem.second.size ( ) > 1 )
if ( elem.first.first.is < string::Epsilon < > > ( ) )
throw exception::CommonException ( "Cant handle conflict in epsilon" );
- for ( const std::pair < const std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > > & elem : parseTable ) {
+ for ( const std::pair < const std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > > & elem : parseTable ) {
if ( elem.first.first.is < string::Epsilon < > > ( ) ) continue;
const DefaultSymbolType & terminal = elem.first.first.get < DefaultSymbolType > ( );
@@ -58,7 +58,7 @@ grammar::CFG < > DeterministicLL1Grammar::convert ( const grammar::CFG < > & par
if ( !deterministic ) continue;
- for ( const std::pair < const std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > > & elem : parseTable ) {
+ for ( const std::pair < const std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > > & elem : parseTable ) {
if ( elem.first.first.is < string::Epsilon < > > ( ) ) continue;
const DefaultSymbolType & terminal = elem.first.first.get < DefaultSymbolType > ( );
diff --git a/alib2algo_experimental/src/grammar/parsing/DeterministicLL1ParseTable.cpp b/alib2algo_experimental/src/grammar/parsing/DeterministicLL1ParseTable.cpp
index 63f6e1bcc1e68a72df7b14c4f7c6633cd27747af..298b3b243dabbc42ecbec220de58eb8f039fc258 100644
--- a/alib2algo_experimental/src/grammar/parsing/DeterministicLL1ParseTable.cpp
+++ b/alib2algo_experimental/src/grammar/parsing/DeterministicLL1ParseTable.cpp
@@ -13,15 +13,15 @@ namespace grammar {
namespace parsing {
-std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::vector < DefaultSymbolType > > DeterministicLL1ParseTable::parseTable ( const std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > > & parseTable ) {
+std::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::vector < DefaultSymbolType > > DeterministicLL1ParseTable::parseTable ( const std::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > > & parseTable ) {
- for ( const std::pair < const std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > > & elem : parseTable )
+ for ( const std::pair < const std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > > & elem : parseTable )
if ( elem.second.size ( ) > 1 )
throw exception::CommonException ( "Cant handle conflict in epsilon" );
- std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::vector < DefaultSymbolType > > res;
+ std::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::vector < DefaultSymbolType > > res;
- for ( const std::pair < const std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > > & elem : parseTable )
+ for ( const std::pair < const std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > > & elem : parseTable )
if ( elem.second.size ( ) == 1 )
res.insert ( std::make_pair ( elem.first, * elem.second.begin ( ) ) );
diff --git a/alib2algo_experimental/src/grammar/parsing/DeterministicLL1ParseTable.h b/alib2algo_experimental/src/grammar/parsing/DeterministicLL1ParseTable.h
index 9597e5a50460f6126aad5ef5bfbd91c1d8f42cae..27c9ac72b7a67649fcddd4f841f74ddb1b86e9d5 100644
--- a/alib2algo_experimental/src/grammar/parsing/DeterministicLL1ParseTable.h
+++ b/alib2algo_experimental/src/grammar/parsing/DeterministicLL1ParseTable.h
@@ -21,7 +21,7 @@ namespace parsing {
class DeterministicLL1ParseTable {
public:
- static std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::vector < DefaultSymbolType > > parseTable ( const std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > > & parseTable );
+ static std::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::vector < DefaultSymbolType > > parseTable ( const std::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > > & parseTable );
};
} /* namespace parsing */
diff --git a/alib2algo_experimental/src/grammar/parsing/First.cpp b/alib2algo_experimental/src/grammar/parsing/First.cpp
index 19cd4f71b9aaf6d222ee03070eccd520a2a7466b..a0081d98dce167016b37c0cecba0d463d3e7e681 100644
--- a/alib2algo_experimental/src/grammar/parsing/First.cpp
+++ b/alib2algo_experimental/src/grammar/parsing/First.cpp
@@ -23,7 +23,7 @@ namespace grammar {
namespace parsing {
-std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > First::first ( const std::set < DefaultSymbolType > & terminals, const std::set < DefaultSymbolType > & nonterminals, const std::map < DefaultSymbolType, std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > > & firstOfNonterminal, const std::vector < DefaultSymbolType > & rhs ) {
+std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > First::first ( const std::set < DefaultSymbolType > & terminals, const std::set < DefaultSymbolType > & nonterminals, const std::map < DefaultSymbolType, std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > & firstOfNonterminal, const std::vector < DefaultSymbolType > & rhs ) {
// 1. FIRST(\varepsilon) = { \varepsilon }
if ( rhs.size ( ) == 0 ) {
return { string::Epsilon < >::EPSILON };
@@ -41,10 +41,10 @@ std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > First::firs
// 5. FIRST(A \alpha) = (first(A) - \varepsilon) \cup FIRST(\alpha) if A \in N and \varepsilon \in first(A)
else if ( nonterminals.count ( rhs[0] ) && firstOfNonterminal.find ( rhs[0] )->second.count ( string::Epsilon < >::EPSILON ) ) {
- std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > res = firstOfNonterminal.find ( rhs[0] )->second;
+ std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > res = firstOfNonterminal.find ( rhs[0] )->second;
res.erase ( string::Epsilon < >::EPSILON );
- std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > next = first ( terminals, nonterminals, firstOfNonterminal, std::vector < DefaultSymbolType > ( rhs.begin ( ) + 1, rhs.end ( ) ) );
+ std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > next = first ( terminals, nonterminals, firstOfNonterminal, std::vector < DefaultSymbolType > ( rhs.begin ( ) + 1, rhs.end ( ) ) );
res.insert ( next.begin ( ), next.end ( ) );
return res;
} else {
@@ -52,7 +52,7 @@ std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > First::firs
}
}
-std::map < DefaultSymbolType, std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > > First::first ( const std::set < DefaultSymbolType > & terminals, const std::set < DefaultSymbolType > & nonterminals, const std::map < DefaultSymbolType, std::set < std::vector < DefaultSymbolType > > > & rules ) {
+std::map < DefaultSymbolType, std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > First::first ( const std::set < DefaultSymbolType > & terminals, const std::set < DefaultSymbolType > & nonterminals, const std::map < DefaultSymbolType, std::set < std::vector < DefaultSymbolType > > > & rules ) {
/*
*
* 1. foreach A \in N: first(A) = \emptyset
@@ -61,17 +61,17 @@ std::map < DefaultSymbolType, std::set < std::variant < DefaultSymbolType, strin
* 3. repeat step 2 if at least one set first(A) has changed
*
*/
- std::map < DefaultSymbolType, std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > > firstOfNonterminal1;
+ std::map < DefaultSymbolType, std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > firstOfNonterminal1;
for ( const DefaultSymbolType & nonterminal : nonterminals )
firstOfNonterminal1[nonterminal];
- std::map < DefaultSymbolType, std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > > firstOfNonterminal2 = firstOfNonterminal1;
+ std::map < DefaultSymbolType, std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > firstOfNonterminal2 = firstOfNonterminal1;
do {
for ( const std::pair < const DefaultSymbolType, std::set < std::vector < DefaultSymbolType > > > & rule : rules )
for ( const std::vector < DefaultSymbolType > & rhs : rule.second ) {
- std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > newFirst = first ( terminals, nonterminals, firstOfNonterminal1, rhs );
+ std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > newFirst = first ( terminals, nonterminals, firstOfNonterminal1, rhs );
firstOfNonterminal2[rule.first].insert ( newFirst.begin ( ), newFirst.end ( ) );
}
@@ -86,10 +86,10 @@ std::map < DefaultSymbolType, std::set < std::variant < DefaultSymbolType, strin
}
template < class T >
-std::map < std::vector < DefaultSymbolType >, std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > > First::first ( const T & grammar ) {
- std::map < DefaultSymbolType, std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > > firstNt = first ( grammar.getTerminalAlphabet ( ), grammar.getNonterminalAlphabet ( ), grammar.getRawRules ( ) );
+std::map < std::vector < DefaultSymbolType >, std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > First::first ( const T & grammar ) {
+ std::map < DefaultSymbolType, std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > firstNt = first ( grammar.getTerminalAlphabet ( ), grammar.getNonterminalAlphabet ( ), grammar.getRawRules ( ) );
- std::map < std::vector < DefaultSymbolType >, std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > > res;
+ std::map < std::vector < DefaultSymbolType >, std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > res;
for ( const std::pair < const DefaultSymbolType, std::set < std::vector < DefaultSymbolType > > > & rule : grammar.getRawRules ( ) )
for ( const std::vector < DefaultSymbolType > & rhs : rule.second )
@@ -99,8 +99,8 @@ std::map < std::vector < DefaultSymbolType >, std::set < std::variant < DefaultS
}
template < class T >
-std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > First::first ( const T & grammar, const std::vector < DefaultSymbolType > & rhs ) {
- std::map < DefaultSymbolType, std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > > firstNt = first ( grammar.getTerminalAlphabet ( ), grammar.getNonterminalAlphabet ( ), grammar.getRawRules ( ) );
+std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > First::first ( const T & grammar, const std::vector < DefaultSymbolType > & rhs ) {
+ std::map < DefaultSymbolType, std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > firstNt = first ( grammar.getTerminalAlphabet ( ), grammar.getNonterminalAlphabet ( ), grammar.getRawRules ( ) );
return first ( grammar.getTerminalAlphabet ( ), grammar.getNonterminalAlphabet ( ), firstNt, rhs );
}
@@ -115,7 +115,7 @@ auto FirstLeftRG = registration::OverloadRegister < FirstBase1, FirstResult1, gr
auto FirstRightLG = registration::OverloadRegister < FirstBase1, FirstResult1, grammar::RightLG < > > ( First::first );
auto FirstRightRG = registration::OverloadRegister < FirstBase1, FirstResult1, grammar::RightRG < > > ( First::first );
-std::map < std::vector < DefaultSymbolType >, std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > > First::first ( const grammar::Grammar & grammar ) {
+std::map < std::vector < DefaultSymbolType >, std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > First::first ( const grammar::Grammar & grammar ) {
return FirstBase1::dispatch ( grammar.getData ( ) );
}
@@ -129,7 +129,7 @@ auto FirstLeftRG2 = registration::OverloadRegister < FirstBase2, FirstResult2, g
auto FirstRightLG2 = registration::OverloadRegister < FirstBase2, FirstResult2, grammar::RightLG < > > ( First::first );
auto FirstRightRG2 = registration::OverloadRegister < FirstBase2, FirstResult2, grammar::RightRG < > > ( First::first );
-std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > First::first ( const grammar::Grammar & grammar, const std::vector < DefaultSymbolType > & rhs ) {
+std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > First::first ( const grammar::Grammar & grammar, const std::vector < DefaultSymbolType > & rhs ) {
return FirstBase2::dispatch ( grammar.getData ( ), rhs );
}
diff --git a/alib2algo_experimental/src/grammar/parsing/First.h b/alib2algo_experimental/src/grammar/parsing/First.h
index fb99c9c491b6e482486a19159932c51d3b4ccef5..bfb608e81a45e71b8ae122356cd7b5820928cf0d 100644
--- a/alib2algo_experimental/src/grammar/parsing/First.h
+++ b/alib2algo_experimental/src/grammar/parsing/First.h
@@ -22,16 +22,16 @@ namespace parsing {
class First;
-typedef std::map < std::vector < DefaultSymbolType >, std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > > FirstResult1;
+typedef std::map < std::vector < DefaultSymbolType >, std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > FirstResult1;
typedef alib::SingleDispatch < First, FirstResult1, const grammar::GrammarBase & > FirstBase1;
-typedef std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > FirstResult2;
+typedef std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > FirstResult2;
typedef alib::SingleDispatch < First, FirstResult2, const grammar::GrammarBase &, const std::vector < DefaultSymbolType > & > FirstBase2;
class First : public FirstBase1, public FirstBase2 {
- static std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > first ( const std::set < DefaultSymbolType > & terminals, const std::set < DefaultSymbolType > & nonterminals, const std::map < DefaultSymbolType, std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > > & firstOfNonterminal, const std::vector < DefaultSymbolType > & rhs );
+ static std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > first ( const std::set < DefaultSymbolType > & terminals, const std::set < DefaultSymbolType > & nonterminals, const std::map < DefaultSymbolType, std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > & firstOfNonterminal, const std::vector < DefaultSymbolType > & rhs );
- static std::map < DefaultSymbolType, std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > > first ( const std::set < DefaultSymbolType > & terminals, const std::set < DefaultSymbolType > & nonterminals, const std::map < DefaultSymbolType, std::set < std::vector < DefaultSymbolType > > > & rules );
+ static std::map < DefaultSymbolType, std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > first ( const std::set < DefaultSymbolType > & terminals, const std::set < DefaultSymbolType > & nonterminals, const std::map < DefaultSymbolType, std::set < std::vector < DefaultSymbolType > > > & rules );
public:
template < class T >
diff --git a/alib2algo_experimental/src/grammar/parsing/Follow.cpp b/alib2algo_experimental/src/grammar/parsing/Follow.cpp
index 05e63a8b97e3ed3c54a8403ba7c23bbb03fbc656..c0eaf41c4c35ea828f5f1149b0cd59672b3a0017 100644
--- a/alib2algo_experimental/src/grammar/parsing/Follow.cpp
+++ b/alib2algo_experimental/src/grammar/parsing/Follow.cpp
@@ -28,7 +28,7 @@ namespace grammar {
namespace parsing {
template < class T >
-void Follow::follow ( const T & grammar, std::map < DefaultSymbolType, std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > > & followSet ) {
+void Follow::follow ( const T & grammar, std::map < DefaultSymbolType, std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > & followSet ) {
for ( const std::pair < const DefaultSymbolType, std::set < std::vector < DefaultSymbolType > > > & rule : grammar.getRawRules ( ) ) {
const DefaultSymbolType & X = rule.first;
@@ -39,7 +39,7 @@ void Follow::follow ( const T & grammar, std::map < DefaultSymbolType, std::set
if ( !grammar.getNonterminalAlphabet ( ).count ( Y ) ) continue;
- std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > firstBeta = First::first ( grammar, std::vector < DefaultSymbolType > ( std::next ( it ), rhs.end ( ) ) );
+ std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > firstBeta = First::first ( grammar, std::vector < DefaultSymbolType > ( std::next ( it ), rhs.end ( ) ) );
if ( firstBeta.count ( string::Epsilon < >::EPSILON ) ) {
firstBeta.erase ( string::Epsilon < >::EPSILON );
@@ -53,7 +53,7 @@ void Follow::follow ( const T & grammar, std::map < DefaultSymbolType, std::set
}
template < class T >
-std::map < DefaultSymbolType, std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > > Follow::follow ( const T & grammar ) {
+std::map < DefaultSymbolType, std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > Follow::follow ( const T & grammar ) {
/*
* 1. Follow(S) = { \varepsilon }
* Follow(A) = {} forall A \in N, A \neq S
@@ -65,14 +65,14 @@ std::map < DefaultSymbolType, std::set < std::variant < DefaultSymbolType, strin
* 3. goto 2 if any follow set was changed in prev step.
*/
- std::map < DefaultSymbolType, std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > > followSet1;
+ std::map < DefaultSymbolType, std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > followSet1;
for ( const DefaultSymbolType & symb : grammar.getNonterminalAlphabet ( ) )
followSet1[symb];
followSet1[grammar.getInitialSymbol ( )] = { string::Epsilon < >::EPSILON };
- std::map < DefaultSymbolType, std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > > followSet2 = followSet1;
+ std::map < DefaultSymbolType, std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > followSet2 = followSet1;
do {
follow ( grammar, followSet2 );
@@ -86,7 +86,7 @@ std::map < DefaultSymbolType, std::set < std::variant < DefaultSymbolType, strin
}
template < class T >
-std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > Follow::follow ( const T & grammar, const DefaultSymbolType & nt ) {
+std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > Follow::follow ( const T & grammar, const DefaultSymbolType & nt ) {
if ( !grammar.getNonterminalAlphabet ( ).count ( nt ) )
throw exception::CommonException ( "Follow: Given symbol is not nonterminal." );
@@ -103,7 +103,7 @@ auto FollowLeftRG = registration::OverloadRegister < FollowBase1, FollowResult1,
auto FollowRightLG = registration::OverloadRegister < FollowBase1, FollowResult1, grammar::RightLG < > > ( Follow::follow );
auto FollowRightRG = registration::OverloadRegister < FollowBase1, FollowResult1, grammar::RightRG < > > ( Follow::follow );
-std::map < DefaultSymbolType, std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > > Follow::follow ( const grammar::Grammar & grammar ) {
+std::map < DefaultSymbolType, std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > Follow::follow ( const grammar::Grammar & grammar ) {
return FollowBase1::dispatch ( grammar.getData ( ) );
}
@@ -117,7 +117,7 @@ auto FollowLeftRG2 = registration::OverloadRegister < FollowBase2, FollowResult2
auto FollowRightLG2 = registration::OverloadRegister < FollowBase2, FollowResult2, grammar::RightLG < > > ( Follow::follow );
auto FollowRightRG2 = registration::OverloadRegister < FollowBase2, FollowResult2, grammar::RightRG < > > ( Follow::follow );
-std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > Follow::follow ( const grammar::Grammar & grammar, const DefaultSymbolType & nt ) {
+std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > Follow::follow ( const grammar::Grammar & grammar, const DefaultSymbolType & nt ) {
return FollowBase2::dispatch ( grammar.getData ( ), nt );
}
diff --git a/alib2algo_experimental/src/grammar/parsing/Follow.h b/alib2algo_experimental/src/grammar/parsing/Follow.h
index 519e229811234bbfc0a74422d1fa9a43b976b2fc..36307c1644b0dd5d7e7b94843ce4d0e6d9be093b 100644
--- a/alib2algo_experimental/src/grammar/parsing/Follow.h
+++ b/alib2algo_experimental/src/grammar/parsing/Follow.h
@@ -22,15 +22,15 @@ namespace parsing {
class Follow;
-typedef std::map < DefaultSymbolType, std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > > FollowResult1;
+typedef std::map < DefaultSymbolType, std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > FollowResult1;
typedef alib::SingleDispatch < Follow, FollowResult1, const grammar::GrammarBase & > FollowBase1;
-typedef std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > FollowResult2;
+typedef std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > FollowResult2;
typedef alib::SingleDispatch < Follow, FollowResult2, const grammar::GrammarBase &, const DefaultSymbolType & > FollowBase2;
class Follow : public FollowBase1, public FollowBase2 {
template < class T >
- static void follow ( const T & grammar, std::map < DefaultSymbolType, std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > > & followSet );
+ static void follow ( const T & grammar, std::map < DefaultSymbolType, std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > & followSet );
static Follow & getInstance ( ) {
static Follow res;
diff --git a/alib2algo_experimental/src/grammar/parsing/LL1ParseTable.cpp b/alib2algo_experimental/src/grammar/parsing/LL1ParseTable.cpp
index 2af69eb5bea5110ea6c5fa8cbaf0bd18d0b34fa9..80dddfda3b17f49e5f1e06c175b17f80510405eb 100644
--- a/alib2algo_experimental/src/grammar/parsing/LL1ParseTable.cpp
+++ b/alib2algo_experimental/src/grammar/parsing/LL1ParseTable.cpp
@@ -25,24 +25,24 @@ namespace grammar {
namespace parsing {
template < class T >
-std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > > LL1ParseTable::parseTable ( const T & grammar ) {
- std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > > res;
+std::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > > LL1ParseTable::parseTable ( const T & grammar ) {
+ std::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > > res;
- std::map < std::vector < DefaultSymbolType >, std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > > first = First::first ( grammar );
- std::map < DefaultSymbolType, std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > > follow = Follow::follow ( grammar );
+ std::map < std::vector < DefaultSymbolType >, std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > first = First::first ( grammar );
+ std::map < DefaultSymbolType, std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > follow = Follow::follow ( grammar );
for ( const std::pair < const DefaultSymbolType, std::set < std::vector < DefaultSymbolType > > > & transition : grammar.getRawRules ( ) ) {
const DefaultSymbolType & lhs = transition.first;
for ( const std::vector < DefaultSymbolType > & rhs : transition.second ) {
- for ( const std::variant < DefaultSymbolType, string::Epsilon < > > & firstElem : first[rhs] ) {
+ for ( const ext::variant < DefaultSymbolType, string::Epsilon < > > & firstElem : first[rhs] ) {
if ( firstElem.is < string::Epsilon < > > ( ) ) continue;
res[std::make_pair ( firstElem, lhs )].insert ( rhs );
}
if ( first[rhs].count ( string::Epsilon < >::EPSILON ) )
- for ( const std::variant < DefaultSymbolType, string::Epsilon < > > & followElem : follow[lhs] )
+ for ( const ext::variant < DefaultSymbolType, string::Epsilon < > > & followElem : follow[lhs] )
res[std::make_pair ( followElem, lhs )].insert ( rhs );
}
@@ -51,17 +51,17 @@ std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >,
return res;
}
-auto LL1ParseTableCFG = registration::OverloadRegister < LL1ParseTable, std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::CFG < > > ( LL1ParseTable::parseTable );
-auto LL1ParseTableEpsilonFreeCFG = registration::OverloadRegister < LL1ParseTable, std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::EpsilonFreeCFG < > > ( LL1ParseTable::parseTable );
-auto LL1ParseTableGNF = registration::OverloadRegister < LL1ParseTable, std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::GNF < > > ( LL1ParseTable::parseTable );
-auto LL1ParseTableCNF = registration::OverloadRegister < LL1ParseTable, std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::CNF < > > ( LL1ParseTable::parseTable );
-auto LL1ParseTableLG = registration::OverloadRegister < LL1ParseTable, std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::LG < > > ( LL1ParseTable::parseTable );
-auto LL1ParseTableLeftLG = registration::OverloadRegister < LL1ParseTable, std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::LeftLG < > > ( LL1ParseTable::parseTable );
-auto LL1ParseTableLeftRG = registration::OverloadRegister < LL1ParseTable, std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::LeftRG < > > ( LL1ParseTable::parseTable );
-auto LL1ParseTableRightLG = registration::OverloadRegister < LL1ParseTable, std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::RightLG < > > ( LL1ParseTable::parseTable );
-auto LL1ParseTableRightRG = registration::OverloadRegister < LL1ParseTable, std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::RightRG < > > ( LL1ParseTable::parseTable );
-
-std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > > LL1ParseTable::parseTable ( const grammar::Grammar & grammar ) {
+auto LL1ParseTableCFG = registration::OverloadRegister < LL1ParseTable, std::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::CFG < > > ( LL1ParseTable::parseTable );
+auto LL1ParseTableEpsilonFreeCFG = registration::OverloadRegister < LL1ParseTable, std::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::EpsilonFreeCFG < > > ( LL1ParseTable::parseTable );
+auto LL1ParseTableGNF = registration::OverloadRegister < LL1ParseTable, std::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::GNF < > > ( LL1ParseTable::parseTable );
+auto LL1ParseTableCNF = registration::OverloadRegister < LL1ParseTable, std::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::CNF < > > ( LL1ParseTable::parseTable );
+auto LL1ParseTableLG = registration::OverloadRegister < LL1ParseTable, std::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::LG < > > ( LL1ParseTable::parseTable );
+auto LL1ParseTableLeftLG = registration::OverloadRegister < LL1ParseTable, std::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::LeftLG < > > ( LL1ParseTable::parseTable );
+auto LL1ParseTableLeftRG = registration::OverloadRegister < LL1ParseTable, std::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::LeftRG < > > ( LL1ParseTable::parseTable );
+auto LL1ParseTableRightLG = registration::OverloadRegister < LL1ParseTable, std::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::RightLG < > > ( LL1ParseTable::parseTable );
+auto LL1ParseTableRightRG = registration::OverloadRegister < LL1ParseTable, std::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::RightRG < > > ( LL1ParseTable::parseTable );
+
+std::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > > LL1ParseTable::parseTable ( const grammar::Grammar & grammar ) {
return dispatch ( grammar.getData ( ) );
}
diff --git a/alib2algo_experimental/src/grammar/parsing/LL1ParseTable.h b/alib2algo_experimental/src/grammar/parsing/LL1ParseTable.h
index 068036c91f26953c6fc7bd2facaaf94589ab1153..7ba2cca746b9116344c67db9b0e533818cc4a204 100644
--- a/alib2algo_experimental/src/grammar/parsing/LL1ParseTable.h
+++ b/alib2algo_experimental/src/grammar/parsing/LL1ParseTable.h
@@ -21,12 +21,12 @@ namespace grammar {
namespace parsing {
-class LL1ParseTable : public alib::SingleDispatch < LL1ParseTable, std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, const grammar::GrammarBase & > {
+class LL1ParseTable : public alib::SingleDispatch < LL1ParseTable, std::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, const grammar::GrammarBase & > {
public:
template < class T >
- static std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > > parseTable ( const T & grammar );
+ static std::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > > parseTable ( const T & grammar );
- static std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > > parseTable ( const grammar::Grammar & grammar );
+ static std::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > > parseTable ( const grammar::Grammar & grammar );
};
diff --git a/alib2algo_experimental/src/grammar/parsing/SLR1ParseTable.cpp b/alib2algo_experimental/src/grammar/parsing/SLR1ParseTable.cpp
index 15425f86279e580b4b4aad8477dce994fe624da7..b4ad8ae343add1071bd0251343e96f80b228d0ab 100644
--- a/alib2algo_experimental/src/grammar/parsing/SLR1ParseTable.cpp
+++ b/alib2algo_experimental/src/grammar/parsing/SLR1ParseTable.cpp
@@ -47,7 +47,7 @@ LRActionTable SLR1ParseTable::getActionTable ( grammar::CFG < > originalGrammar
grammar::parsing::FollowResult2 followSet = grammar::parsing::Follow::follow ( augmentedGrammar, leftHandSide );
std::pair < DefaultSymbolType, std::vector < DefaultSymbolType > > currentRule = { leftHandSide, rightHandSide };
- for ( const std::variant < DefaultSymbolType, string::Epsilon < > > & followSymbol : followSet ) {
+ for ( const ext::variant < DefaultSymbolType, string::Epsilon < > > & followSymbol : followSet ) {
if ( followSymbol.is < DefaultSymbolType > ( ) ) {
insertToActionTable(actionTable, { state, followSymbol.get < DefaultSymbolType > ( ) }, { LRAction::Reduce, currentRule } );
} else {
diff --git a/alib2algo_experimental/test-src/grammar/parsing/FirstTest.cpp b/alib2algo_experimental/test-src/grammar/parsing/FirstTest.cpp
index f0b21a96a68279ff1506ebb63898eab8d01748ff..e609e47419b17ebd940a40a6687e4ebdd98dcc0b 100644
--- a/alib2algo_experimental/test-src/grammar/parsing/FirstTest.cpp
+++ b/alib2algo_experimental/test-src/grammar/parsing/FirstTest.cpp
@@ -44,30 +44,30 @@ void FirstTest::testFirst ( ) {
grammar.addRule ( nF, rhsF2 );
// --------------------------------------------------
- std::map < std::vector < DefaultSymbolType >, std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > > first;
+ std::map < std::vector < DefaultSymbolType >, std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > first;
- first[rhsE1] = std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > {
+ first[rhsE1] = std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
tA, tL
};
- first[rhsE2] = std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > {
+ first[rhsE2] = std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
tA, tL
};
- first[rhsT1] = std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > {
+ first[rhsT1] = std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
tA, tL
};
- first[rhsT2] = std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > {
+ first[rhsT2] = std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
tA, tL
};
- first[rhsF1] = std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > {
+ first[rhsF1] = std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
tA
};
- first[rhsF2] = std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > {
+ first[rhsF2] = std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
tL
};
// --------------------------------------------------
- std::map < std::vector < DefaultSymbolType >, std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > > firstAlgo;
+ std::map < std::vector < DefaultSymbolType >, std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > firstAlgo;
for ( const auto & rule : grammar.getRawRules ( ) )
for ( const auto & rhs : rule.second )
@@ -126,54 +126,54 @@ void FirstTest::testFirst ( ) {
grammar.addRule ( nF, rhsF2 );
// --------------------------------------------------
- std::map < std::vector < DefaultSymbolType >, std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > > first;
+ std::map < std::vector < DefaultSymbolType >, std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > first;
- first[rhsS1] = std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > {
+ first[rhsS1] = std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
tA, tB
};
- first[rhsS2] = std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > {
+ first[rhsS2] = std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
tD
};
- first[rhsS3] = std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > {
+ first[rhsS3] = std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
tC
};
- first[rhsA1] = std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > {
+ first[rhsA1] = std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
tA
};
- first[rhsA2] = std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > {
+ first[rhsA2] = std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
tB
};
- first[rhsB1] = std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > {
+ first[rhsB1] = std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
tA
};
- first[rhsB2] = std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > {
+ first[rhsB2] = std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
tB
};
- first[rhsC1] = std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > {
+ first[rhsC1] = std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
tA
};
- first[rhsC2] = std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > {
+ first[rhsC2] = std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
tE
};
- first[rhsD1] = std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > {
+ first[rhsD1] = std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
tC
};
- first[rhsE1] = std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > {
+ first[rhsE1] = std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
tC
};
- first[rhsE2] = std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > {
+ first[rhsE2] = std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
string::Epsilon < >::EPSILON
};
- first[rhsF1] = std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > {
+ first[rhsF1] = std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
tE
};
- first[rhsF2] = std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > {
+ first[rhsF2] = std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
string::Epsilon < >::EPSILON
};
// --------------------------------------------------
- std::map < std::vector < DefaultSymbolType >, std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > > firstAlgo;
+ std::map < std::vector < DefaultSymbolType >, std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > firstAlgo;
for ( const auto & rule : grammar.getRawRules ( ) )
for ( const auto & rhs : rule.second )
@@ -197,7 +197,7 @@ void FirstTest::testFirst2 ( ) {
grammar.addRule ( A, std::vector < DefaultSymbolType > { A, c } );
grammar.addRule ( A, std::vector < DefaultSymbolType > { d } );
- std::map < std::vector < DefaultSymbolType >, std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > > res = { { { d }, { d } }, { { A, c }, { d } } };
+ std::map < std::vector < DefaultSymbolType >, std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > res = { { { d }, { d } }, { { A, c }, { d } } };
CPPUNIT_ASSERT ( res == grammar::parsing::First::first ( grammar ) );
}
@@ -224,7 +224,7 @@ void FirstTest::testFirst3 ( ) {
grammar.addRule ( B, std::vector < DefaultSymbolType > { f, S } );
grammar.addRule ( B, std::vector < DefaultSymbolType > { } );
- std::map < std::vector < DefaultSymbolType >, std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > > res =
+ std::map < std::vector < DefaultSymbolType >, std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > res =
{
{ { A, a }, { c, f, a } }, { { b, S }, { b } }, { { c, A, d }, { c } }, { { B }, { f, string::Epsilon < >::EPSILON } }, { { f, S }, { f } }, { { }, { string::Epsilon < >::EPSILON } }
};
diff --git a/alib2algo_experimental/test-src/grammar/parsing/FollowTest.cpp b/alib2algo_experimental/test-src/grammar/parsing/FollowTest.cpp
index d416735cba3003a8dc3024a36b775d01e14d20b6..d7b1fcf6e62b38b5c3c1c8837ea468c7b94170be 100644
--- a/alib2algo_experimental/test-src/grammar/parsing/FollowTest.cpp
+++ b/alib2algo_experimental/test-src/grammar/parsing/FollowTest.cpp
@@ -44,21 +44,21 @@ void FollowTest::testFollow ( ) {
grammar.addRule ( nF, rhsF2 );
// --------------------------------------------------
- std::map < DefaultSymbolType, std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > > follow;
+ std::map < DefaultSymbolType, std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > follow;
- follow[nE] = std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > {
+ follow[nE] = std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
string::Epsilon < >::EPSILON, tP, tR
};
- follow[nT] = std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > {
+ follow[nT] = std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
string::Epsilon < >::EPSILON, tP, tR, tS
};
- follow[nF] = std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > {
+ follow[nF] = std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
string::Epsilon < >::EPSILON, tP, tR, tS
};
// --------------------------------------------------
- std::map < DefaultSymbolType, std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > > followAlgo;
+ std::map < DefaultSymbolType, std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > followAlgo;
for ( const auto & nt : grammar.getNonterminalAlphabet ( ) )
followAlgo[nt] = grammar::parsing::Follow::follow ( grammar, nt );
@@ -118,33 +118,33 @@ void FollowTest::testFollow ( ) {
grammar.addRule ( nF, rhsF2 );
// --------------------------------------------------
- std::map < DefaultSymbolType, std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > > follow;
+ std::map < DefaultSymbolType, std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > follow;
- follow[nS] = std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > {
+ follow[nS] = std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
string::Epsilon < >::EPSILON
};
- follow[nA] = std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > {
+ follow[nA] = std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
string::Epsilon < >::EPSILON
};
- follow[nB] = std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > {
+ follow[nB] = std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
tD
};
- follow[nC] = std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > {
+ follow[nC] = std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
string::Epsilon < >::EPSILON
};
- follow[nD] = std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > {
+ follow[nD] = std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
tD
};
- follow[nE] = std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > {
+ follow[nE] = std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
string::Epsilon < >::EPSILON
};
- follow[nF] = std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > {
+ follow[nF] = std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
tD
};
// --------------------------------------------------
- std::map < DefaultSymbolType, std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > > followAlgo;
+ std::map < DefaultSymbolType, std::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > followAlgo;
for ( const auto & nt : grammar.getNonterminalAlphabet ( ) )
followAlgo[nt] = grammar::parsing::Follow::follow ( grammar, nt );
diff --git a/alib2algo_experimental/test-src/grammar/parsing/LL1ParseTable.cpp b/alib2algo_experimental/test-src/grammar/parsing/LL1ParseTable.cpp
index 9080e3e7f78f09a354f2ab6421251c581e600db3..bd3387b749afc246102fcef470c8cbae70e1a888 100644
--- a/alib2algo_experimental/test-src/grammar/parsing/LL1ParseTable.cpp
+++ b/alib2algo_experimental/test-src/grammar/parsing/LL1ParseTable.cpp
@@ -50,7 +50,7 @@ void LL1ParseTable::testLL1Table ( ) {
grammar.addRule ( nF, rhsF2 );
// --------------------------------------------------
- std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > > parseTable;
+ std::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > > parseTable;
parseTable[std::make_pair ( tA, nE )].insert ( rhsE1 );
parseTable[std::make_pair ( tL, nE )].insert ( rhsE1 );
@@ -72,7 +72,7 @@ void LL1ParseTable::testLL1Table ( ) {
// --------------------------------------------------
- std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > > parseTableAlgo = grammar::parsing::LL1ParseTable::parseTable ( grammar );
+ std::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > > parseTableAlgo = grammar::parsing::LL1ParseTable::parseTable ( grammar );
std::cout << parseTable << std::endl;
std::cout << parseTableAlgo << std::endl;
diff --git a/alib2common/src/container/ObjectsVariant.h b/alib2common/src/container/ObjectsVariant.h
index 22a8f2709c1c181a479d4d410c004c6b7fa803c5..838e91d18276a78454a5d8a08cd4d35732b711c4 100644
--- a/alib2common/src/container/ObjectsVariant.h
+++ b/alib2common/src/container/ObjectsVariant.h
@@ -26,10 +26,10 @@ private:
public:
template < class ... Ts >
- static std::variant < Ts ... > parseRaw ( std::deque < sax::Token >::iterator & input );
+ static ext::variant < Ts ... > parseRaw ( std::deque < sax::Token >::iterator & input );
template < class ... Ts >
- static void compose ( std::deque < sax::Token > & out, const std::variant < Ts ... > & input );
+ static void compose ( std::deque < sax::Token > & out, const ext::variant < Ts ... > & input );
};
template < typename T >
@@ -58,8 +58,8 @@ T parseVariantHelper ( std::deque < sax::Token >::iterator & input ) {
}
template < typename ... Ts >
-std::variant < Ts ... > ObjectsVariant::parseRaw ( std::deque < sax::Token >::iterator & input ) {
- return parseVariantHelper < std::variant < Ts ... >, Ts ... > ( input );
+ext::variant < Ts ... > ObjectsVariant::parseRaw ( std::deque < sax::Token >::iterator & input ) {
+ return parseVariantHelper < ext::variant < Ts ... >, Ts ... > ( input );
}
template < typename T >
@@ -99,8 +99,8 @@ void composeVariantHelper ( std::deque < sax::Token > & out, const T & container
}
template < typename ... Ts >
-void ObjectsVariant::compose ( std::deque < sax::Token > & out, const std::variant < Ts ... > & container ) {
- composeVariantHelper < std::variant < Ts ... >, Ts ... > ( out, container );
+void ObjectsVariant::compose ( std::deque < sax::Token > & out, const ext::variant < Ts ... > & container ) {
+ composeVariantHelper < ext::variant < Ts ... >, Ts ... > ( out, container );
}
} /* namespace container */
@@ -108,30 +108,30 @@ void ObjectsVariant::compose ( std::deque < sax::Token > & out, const std::varia
namespace alib {
template < typename ... Ts >
-struct xmlApi < std::variant < Ts ... > > {
- static std::variant < Ts ... > parse ( std::deque < sax::Token >::iterator & input );
+struct xmlApi < ext::variant < Ts ... > > {
+ static ext::variant < Ts ... > parse ( std::deque < sax::Token >::iterator & input );
static bool first ( const std::deque < sax::Token >::const_iterator & input );
static std::string xmlTagName ( );
- static void compose ( std::deque < sax::Token > & output, const std::variant < Ts ... > & data );
+ static void compose ( std::deque < sax::Token > & output, const ext::variant < Ts ... > & data );
};
template < typename ... Ts >
-std::variant < Ts ... > xmlApi < std::variant < Ts ... > >::parse ( std::deque < sax::Token >::iterator & input ) {
+ext::variant < Ts ... > xmlApi < ext::variant < Ts ... > >::parse ( std::deque < sax::Token >::iterator & input ) {
return container::ObjectsVariant::parseRaw < Ts ... > ( input );
}
template < typename ... Ts >
-bool xmlApi < std::variant < Ts ... > >::first ( const std::deque < sax::Token >::const_iterator & input ) {
- return container::firstVariantHelper < std::variant < Ts ... >, Ts ... > ( input );
+bool xmlApi < ext::variant < Ts ... > >::first ( const std::deque < sax::Token >::const_iterator & input ) {
+ return container::firstVariantHelper < ext::variant < Ts ... >, Ts ... > ( input );
}
template < typename ... Ts >
-std::string xmlApi < std::variant < Ts ... > >::xmlTagName ( ) {
+std::string xmlApi < ext::variant < Ts ... > >::xmlTagName ( ) {
throw ::exception::CommonException ( "Variant does not have xmlTagName." );
}
template < typename ... Ts >
-void xmlApi < std::variant < Ts ... > >::compose ( std::deque < sax::Token > & output, const std::variant < Ts ... > & input ) {
+void xmlApi < ext::variant < Ts ... > >::compose ( std::deque < sax::Token > & output, const ext::variant < Ts ... > & input ) {
return container::ObjectsVariant::compose < Ts ... > ( output, input );
}
diff --git a/alib2common/src/core/visitor.hpp b/alib2common/src/core/visitor.hpp
index 1c3b52374850be9e9aac3d5cfd715d842c8605d3..490d8f9e31d2db18afa7435632911dea5feaf57c 100644
--- a/alib2common/src/core/visitor.hpp
+++ b/alib2common/src/core/visitor.hpp
@@ -8,7 +8,7 @@
#ifndef VISITOR_HPP_
#define VISITOR_HPP_
-#include <variant>
+#include <utility>
namespace alib {
@@ -37,7 +37,7 @@ class VisitorContextBase : public VisitorContextBaseBuilder < Visitables ... > {
template < class ReturnType, class Visitor, class ... Params >
class VisitorContextAux {
- typename std::aligned_storage < std::SizeOf < ReturnType >::size, std::AlignOf < ReturnType >::align >::type result;
+ typename std::aligned_storage < ext::SizeOf < ReturnType >::size, ext::AlignOf < ReturnType >::align >::type result;
std::tuple < Params ... > m_params;
diff --git a/alib2common/test-src/container/ContainerTest.cpp b/alib2common/test-src/container/ContainerTest.cpp
index e996ef394a4749e8813bf35281f1b8f7e2f70968..25a0cf3cc7eb1ad0284354b12fa883569557918d 100644
--- a/alib2common/test-src/container/ContainerTest.cpp
+++ b/alib2common/test-src/container/ContainerTest.cpp
@@ -59,13 +59,13 @@ void ContainerTest::testXMLParser ( ) {
void ContainerTest::testVariantParsing ( ) {
{
std::string string = "<String>aaa</String>";
- std::variant < int, std::string > object = alib::XmlDataFactory::fromString ( string );
+ ext::variant < int, std::string > object = alib::XmlDataFactory::fromString ( string );
CPPUNIT_ASSERT ( "aaa" == object.get < std::string > ( ) );
std::string string2 = alib::XmlDataFactory::toString ( object );
- std::variant < int, std::string > object2 = alib::XmlDataFactory::fromString ( string2 );
+ ext::variant < int, std::string > object2 = alib::XmlDataFactory::fromString ( string2 );
CPPUNIT_ASSERT ( object == object2 );
}
diff --git a/alib2data/src/automaton/FSM/EpsilonNFA.h b/alib2data/src/automaton/FSM/EpsilonNFA.h
index cc4e806adeba496c8d6b7fc1ae3bdf1ee5341bd1..fbf13d9e8ce35f9d045b88378e0c6171b15399b8 100644
--- a/alib2data/src/automaton/FSM/EpsilonNFA.h
+++ b/alib2data/src/automaton/FSM/EpsilonNFA.h
@@ -42,7 +42,7 @@ class InitialState;
template<class SymbolType, class EpsilonType, class StateType >
class EpsilonNFA final : public AutomatonBase, public alib::Components < EpsilonNFA < SymbolType, EpsilonType, StateType >, SymbolType, std::tuple < InputAlphabet >, std::tuple < >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
protected:
- std::map < std::pair < StateType, std::variant < EpsilonType, SymbolType > >, std::set < StateType > > transitions;
+ std::map < std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, std::set < StateType > > transitions;
public:
explicit EpsilonNFA ( StateType initialState );
@@ -122,7 +122,7 @@ public:
* @param next next state
* @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
*/
- bool addTransition ( StateType from, std::variant < EpsilonType, SymbolType > input, StateType to );
+ bool addTransition ( StateType from, ext::variant < EpsilonType, SymbolType > input, StateType to );
/**
* Adds transition defined by parameters to the automaton.
@@ -148,7 +148,7 @@ public:
* @param next next state
* @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
*/
- void addTransitions ( StateType from, std::variant < EpsilonType, SymbolType > input, std::set < StateType > to );
+ void addTransitions ( StateType from, ext::variant < EpsilonType, SymbolType > input, std::set < StateType > to );
/**
* Adds transition defined by parameters to the automaton.
@@ -184,7 +184,7 @@ public:
/**
* @return automaton transitions
*/
- const std::map < std::pair < StateType, std::variant < EpsilonType, SymbolType > >, std::set < StateType > > & getTransitions ( ) const;
+ const std::map < std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, std::set < StateType > > & getTransitions ( ) const;
/**
* @return automaton epsilon transitions
@@ -199,7 +199,7 @@ public:
/**
* @return automaton transitions from state
*/
- std::map < std::pair < StateType, std::variant < EpsilonType, SymbolType > >, std::set < StateType > > getTransitionsFromState ( const StateType & from ) const;
+ std::map < std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, std::set < StateType > > getTransitionsFromState ( const StateType & from ) const;
/**
* @return automaton epsilon transitions from state
@@ -214,7 +214,7 @@ public:
/**
* @return automaton transitions to state
*/
- std::map < std::pair < StateType, std::variant < EpsilonType, SymbolType > >, std::set < StateType > > getTransitionsToState ( const StateType & from ) const;
+ std::map < std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, std::set < StateType > > getTransitionsToState ( const StateType & from ) const;
/**
* @return automaton epsilon transitions to state
@@ -289,9 +289,9 @@ public:
EpsilonNFA < > * res = new EpsilonNFA < > ( std::move ( states ), std::move ( alphabet ), std::move ( initialState ), std::move ( finalStates ) );
- for ( std::pair < std::pair < StateType, std::variant < EpsilonType, SymbolType > >, std::set < StateType > > && transition : std::make_moveable_map ( transitions ) ) {
+ for ( std::pair < std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, std::set < StateType > > && transition : std::make_moveable_map ( transitions ) ) {
DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) );
- std::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( transition.first.second ) );
+ ext::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( transition.first.second ) );
std::set < DefaultStateType > targets = AutomatonNormalize::normalizeStates ( std::move ( transition.second ) );
res->addTransitions ( std::move ( from ), std::move ( input ), std::move ( targets ) );
@@ -321,11 +321,11 @@ EpsilonNFA < SymbolType, EpsilonType, StateType >::EpsilonNFA ( StateType initia
template<class SymbolType, class EpsilonType, class StateType >
EpsilonNFA < SymbolType, EpsilonType, StateType >::EpsilonNFA ( const MultiInitialStateNFA < SymbolType, StateType > & other ) : EpsilonNFA ( other.getStates ( ) + std::set < StateType > { common::createUnique ( label::InitialStateLabel::instance < StateType > ( ), other.getStates ( ) ) }, other.getInputAlphabet ( ), common::createUnique ( label::InitialStateLabel::instance < StateType > ( ), other.getStates ( ) ), other.getFinalStates ( ) ) {
for ( const auto & transition : other.getTransitions ( ) ) {
- std::pair < StateType, std::variant < EpsilonType, SymbolType > > key = std::make_pair ( transition.first.first, std::variant < EpsilonType, SymbolType > ( transition.first.second ) );
+ std::pair < StateType, ext::variant < EpsilonType, SymbolType > > key = std::make_pair ( transition.first.first, ext::variant < EpsilonType, SymbolType > ( transition.first.second ) );
transitions[key] = transition.second;
}
- std::pair < StateType, std::variant < EpsilonType, SymbolType > > key = std::make_pair ( getInitialState ( ), std::variant < EpsilonType, SymbolType >::template from < EpsilonType > ( ) );
+ std::pair < StateType, ext::variant < EpsilonType, SymbolType > > key = std::make_pair ( getInitialState ( ), ext::variant < EpsilonType, SymbolType >::template from < EpsilonType > ( ) );
transitions[key] = other.getInitialStates ( );
}
@@ -333,7 +333,7 @@ EpsilonNFA < SymbolType, EpsilonType, StateType >::EpsilonNFA ( const MultiIniti
template<class SymbolType, class EpsilonType, class StateType >
EpsilonNFA < SymbolType, EpsilonType, StateType >::EpsilonNFA ( const NFA < SymbolType, StateType > & other ) : EpsilonNFA ( other.getStates ( ), other.getInputAlphabet ( ), other.getInitialState ( ), other.getFinalStates ( ) ) {
for ( const auto & transition : other.getTransitions ( ) ) {
- std::pair < StateType, std::variant < EpsilonType, SymbolType > > key = std::make_pair ( transition.first.first, std::variant < EpsilonType, SymbolType > ( transition.first.second ) );
+ std::pair < StateType, ext::variant < EpsilonType, SymbolType > > key = std::make_pair ( transition.first.first, ext::variant < EpsilonType, SymbolType > ( transition.first.second ) );
transitions[key] = transition.second;
}
}
@@ -341,7 +341,7 @@ EpsilonNFA < SymbolType, EpsilonType, StateType >::EpsilonNFA ( const NFA < Symb
template<class SymbolType, class EpsilonType, class StateType >
EpsilonNFA < SymbolType, EpsilonType, StateType >::EpsilonNFA ( const DFA < SymbolType, StateType > & other ) : EpsilonNFA ( other.getStates ( ), other.getInputAlphabet ( ), other.getInitialState ( ), other.getFinalStates ( ) ) {
for ( const auto & transition : other.getTransitions ( ) ) {
- std::pair < StateType, std::variant < EpsilonType, SymbolType > > key = std::make_pair ( transition.first.first, std::variant < EpsilonType, SymbolType > ( transition.first.second ) );
+ std::pair < StateType, ext::variant < EpsilonType, SymbolType > > key = std::make_pair ( transition.first.first, ext::variant < EpsilonType, SymbolType > ( transition.first.second ) );
transitions[key].insert ( transition.second );
}
}
@@ -357,7 +357,7 @@ AutomatonBase * EpsilonNFA < SymbolType, EpsilonType, StateType >::plunder ( ) &
}
template<class SymbolType, class EpsilonType, class StateType >
-bool EpsilonNFA < SymbolType, EpsilonType, StateType >::addTransition ( StateType from, std::variant < EpsilonType, SymbolType > input, StateType to ) {
+bool EpsilonNFA < SymbolType, EpsilonType, StateType >::addTransition ( StateType from, ext::variant < EpsilonType, SymbolType > input, StateType to ) {
if ( !getStates ( ).count ( from ) )
throw AutomatonException ( "State \"" + ext::to_string ( from ) + "\" doesn't exist." );
@@ -367,27 +367,27 @@ bool EpsilonNFA < SymbolType, EpsilonType, StateType >::addTransition ( StateTyp
if ( !getStates ( ).count ( to ) )
throw AutomatonException ( "State \"" + ext::to_string ( to ) + "\" doesn't exist." );
- std::pair < StateType, std::variant < EpsilonType, SymbolType > > key = std::make_pair ( std::move ( from ), std::move ( input ) );
+ std::pair < StateType, ext::variant < EpsilonType, SymbolType > > key = std::make_pair ( std::move ( from ), std::move ( input ) );
return transitions[std::move ( key )].insert ( std::move ( to ) ).second;
}
template<class SymbolType, class EpsilonType, class StateType >
bool EpsilonNFA < SymbolType, EpsilonType, StateType >::addTransition ( StateType from, SymbolType input, StateType to ) {
- std::variant < EpsilonType, SymbolType > inputVariant ( std::move ( input ) );
+ ext::variant < EpsilonType, SymbolType > inputVariant ( std::move ( input ) );
return addTransition ( std::move ( from ), std::move ( inputVariant ), std::move ( to ) );
}
template<class SymbolType, class EpsilonType, class StateType >
bool EpsilonNFA < SymbolType, EpsilonType, StateType >::addTransition ( StateType from, StateType to ) {
- auto inputVariant = std::variant < EpsilonType, SymbolType >::template from < EpsilonType > ( );
+ auto inputVariant = ext::variant < EpsilonType, SymbolType >::template from < EpsilonType > ( );
return addTransition ( std::move ( from ), std::move ( inputVariant ), std::move ( to ) );
}
template < class SymbolType, class EpsilonType, class StateType >
-void EpsilonNFA < SymbolType, EpsilonType, StateType >::addTransitions ( StateType from, std::variant < EpsilonType, SymbolType > input, std::set < StateType > to ) {
+void EpsilonNFA < SymbolType, EpsilonType, StateType >::addTransitions ( StateType from, ext::variant < EpsilonType, SymbolType > input, std::set < StateType > to ) {
if ( !getStates ( ).count ( from ) )
throw AutomatonException ( "State \"" + ext::to_string ( from ) + "\" doesn't exist." );
@@ -397,44 +397,44 @@ void EpsilonNFA < SymbolType, EpsilonType, StateType >::addTransitions ( StateTy
if ( !std::includes ( getStates ( ).begin ( ), getStates ( ).end ( ), to.begin ( ), to.end ( ) ) )
throw AutomatonException ( "Some target states don't exist." );
- std::pair < StateType, std::variant < EpsilonType, SymbolType > > key = std::make_pair ( std::move ( from ), std::move ( input ) );
+ std::pair < StateType, ext::variant < EpsilonType, SymbolType > > key = std::make_pair ( std::move ( from ), std::move ( input ) );
transitions [ std::move ( key ) ].insert ( std::make_moveable_set ( to ).begin ( ), std::make_moveable_set ( to ).end ( ) );
}
template<class SymbolType, class EpsilonType, class StateType >
void EpsilonNFA < SymbolType, EpsilonType, StateType >::addTransitions ( StateType from, SymbolType input, std::set < StateType > to ) {
- std::variant < EpsilonType, SymbolType > inputVariant ( std::move ( input ) );
+ ext::variant < EpsilonType, SymbolType > inputVariant ( std::move ( input ) );
addTransitions ( std::move ( from ), std::move ( inputVariant ), std::move ( to ) );
}
template<class SymbolType, class EpsilonType, class StateType >
void EpsilonNFA < SymbolType, EpsilonType, StateType >::addTransitions ( StateType from, std::set < StateType > to ) {
- auto inputVariant = std::variant < EpsilonType, SymbolType >::template from < EpsilonType > ( );
+ auto inputVariant = ext::variant < EpsilonType, SymbolType >::template from < EpsilonType > ( );
addTransitions ( std::move ( from ), std::move ( inputVariant ), std::move ( to ) );
}
template<class SymbolType, class EpsilonType, class StateType >
bool EpsilonNFA < SymbolType, EpsilonType, StateType >::removeTransition ( const StateType & from, const SymbolType & input, const StateType & to ) {
- std::variant < EpsilonType, SymbolType > inputVariant ( input );
- std::pair < StateType, std::variant < EpsilonType, SymbolType > > key = std::make_pair ( from, inputVariant );
+ ext::variant < EpsilonType, SymbolType > inputVariant ( input );
+ std::pair < StateType, ext::variant < EpsilonType, SymbolType > > key = std::make_pair ( from, inputVariant );
return transitions[key].erase ( to );
}
template<class SymbolType, class EpsilonType, class StateType >
bool EpsilonNFA < SymbolType, EpsilonType, StateType >::removeTransition ( const StateType & from, const StateType & to ) {
- auto inputVariant = std::variant < EpsilonType, SymbolType >::template from < EpsilonType > ( );
+ auto inputVariant = ext::variant < EpsilonType, SymbolType >::template from < EpsilonType > ( );
- std::pair < StateType, std::variant < EpsilonType, SymbolType > > key = std::make_pair ( from, inputVariant );
+ std::pair < StateType, ext::variant < EpsilonType, SymbolType > > key = std::make_pair ( from, inputVariant );
return transitions[key].erase ( to );
}
template<class SymbolType, class EpsilonType, class StateType >
-const std::map < std::pair < StateType, std::variant < EpsilonType, SymbolType > >, std::set < StateType > > & EpsilonNFA < SymbolType, EpsilonType, StateType >::getTransitions ( ) const {
+const std::map < std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, std::set < StateType > > & EpsilonNFA < SymbolType, EpsilonType, StateType >::getTransitions ( ) const {
return transitions;
}
@@ -442,7 +442,7 @@ template<class SymbolType, class EpsilonType, class StateType >
std::map < StateType, std::set < StateType > > EpsilonNFA < SymbolType, EpsilonType, StateType >::getEpsilonTransitions ( ) const {
std::map < StateType, std::set < StateType > > result;
- for ( const std::pair < const std::pair < StateType, std::variant < EpsilonType, SymbolType > >, std::set < StateType > > & transition : transitions )
+ for ( const std::pair < const std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, std::set < StateType > > & transition : transitions )
if ( transition.first.second.template is < EpsilonType > ( ) )
result[transition.first.first].insert ( transition.second.begin ( ), transition.second.end ( ) );
@@ -453,7 +453,7 @@ template<class SymbolType, class EpsilonType, class StateType >
std::map < std::pair < StateType, SymbolType >, std::set < StateType > > EpsilonNFA < SymbolType, EpsilonType, StateType >::getSymbolTransitions ( ) const {
std::map < std::pair < StateType, SymbolType >, std::set < StateType > > result;
- for ( const std::pair < const std::pair < StateType, std::variant < EpsilonType, SymbolType > >, std::set < StateType > > & transition : transitions )
+ for ( const std::pair < const std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, std::set < StateType > > & transition : transitions )
if ( transition.first.second.template is < SymbolType > ( ) )
result[std::pair < StateType, SymbolType > ( transition.first.first, transition.first.second.template get < SymbolType > ( ) )].insert ( transition.second.begin ( ), transition.second.end ( ) );
@@ -461,13 +461,13 @@ std::map < std::pair < StateType, SymbolType >, std::set < StateType > > Epsilon
}
template<class SymbolType, class EpsilonType, class StateType >
-std::map < std::pair < StateType, std::variant < EpsilonType, SymbolType > >, std::set < StateType > > EpsilonNFA < SymbolType, EpsilonType, StateType >::getTransitionsFromState ( const StateType & from ) const {
+std::map < std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, std::set < StateType > > EpsilonNFA < SymbolType, EpsilonType, StateType >::getTransitionsFromState ( const StateType & from ) const {
if ( !getStates ( ).count ( from ) )
throw AutomatonException ( "State \"" + ext::to_string ( from ) + "\" doesn't exist" );
- std::map < std::pair < StateType, std::variant < EpsilonType, SymbolType > >, std::set < StateType > > transitionsFromState;
+ std::map < std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, std::set < StateType > > transitionsFromState;
- for ( const std::pair < const std::pair < StateType, std::variant < EpsilonType, SymbolType > >, std::set < StateType > > & transition : transitions )
+ for ( const std::pair < const std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, std::set < StateType > > & transition : transitions )
if ( transition.first.first == from )
transitionsFromState[transition.first].insert ( transition.second.begin ( ), transition.second.end ( ) );
@@ -479,7 +479,7 @@ std::map < StateType, std::set < StateType > > EpsilonNFA < SymbolType, EpsilonT
if ( !getStates ( ).count ( from ) )
throw AutomatonException ( "State \"" + ext::to_string ( from ) + "\" doesn't exist" );
- std::pair < StateType, std::variant < EpsilonType, SymbolType > > key ( from, std::variant < EpsilonType, SymbolType >::template from < EpsilonType > ( ) );
+ std::pair < StateType, ext::variant < EpsilonType, SymbolType > > key ( from, ext::variant < EpsilonType, SymbolType >::template from < EpsilonType > ( ) );
std::map < StateType, std::set < StateType > > res;
auto transition = transitions.find ( key );
@@ -496,7 +496,7 @@ std::map < std::pair < StateType, SymbolType >, std::set < StateType > > Epsilon
std::map < std::pair < StateType, SymbolType >, std::set < StateType > > transitionsFromState;
- for ( const std::pair < const std::pair < StateType, std::variant < EpsilonType, SymbolType > >, std::set < StateType > > & transition : transitions )
+ for ( const std::pair < const std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, std::set < StateType > > & transition : transitions )
if ( ( transition.first.first == from ) && transition.first.second.template is < SymbolType > ( ) )
transitionsFromState[std::pair < StateType, SymbolType > ( transition.first.first, transition.first.second.template get < SymbolType > ( ) )].insert ( transition.second.begin ( ), transition.second.end ( ) );
@@ -504,13 +504,13 @@ std::map < std::pair < StateType, SymbolType >, std::set < StateType > > Epsilon
}
template<class SymbolType, class EpsilonType, class StateType >
-std::map < std::pair < StateType, std::variant < EpsilonType, SymbolType > >, std::set < StateType > > EpsilonNFA < SymbolType, EpsilonType, StateType >::getTransitionsToState ( const StateType & to ) const {
+std::map < std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, std::set < StateType > > EpsilonNFA < SymbolType, EpsilonType, StateType >::getTransitionsToState ( const StateType & to ) const {
if ( !getStates ( ).count ( to ) )
throw AutomatonException ( "State \"" + ext::to_string ( to ) + "\" doesn't exist" );
- std::map < std::pair < StateType, std::variant < EpsilonType, SymbolType > >, std::set < StateType > > transitionsToState;
+ std::map < std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, std::set < StateType > > transitionsToState;
- for ( const std::pair < const std::pair < StateType, std::variant < EpsilonType, SymbolType > >, std::set < StateType > > & transition : transitions )
+ for ( const std::pair < const std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, std::set < StateType > > & transition : transitions )
if ( transition.second.find ( to ) != transition.second.end ( ) )
transitionsToState[transition.first].insert ( transition.second.begin ( ), transition.second.end ( ) );
@@ -524,7 +524,7 @@ std::map < StateType, std::set < StateType > > EpsilonNFA < SymbolType, EpsilonT
std::map < StateType, std::set < StateType > > transitionsToState;
- for ( const std::pair < const std::pair < StateType, std::variant < EpsilonType, SymbolType > >, std::set < StateType > > & transition : transitions )
+ for ( const std::pair < const std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, std::set < StateType > > & transition : transitions )
if ( ( transition.second.find ( to ) != transition.second.end ( ) ) && transition.first.second.template is < EpsilonType > ( ) )
transitionsToState[transition.first.first].insert ( transition.second.begin ( ), transition.second.end ( ) );
@@ -538,7 +538,7 @@ std::map < std::pair < StateType, SymbolType >, std::set < StateType > > Epsilon
std::map < std::pair < StateType, SymbolType >, std::set < StateType > > transitionsToState;
- for ( const std::pair < const std::pair < StateType, std::variant < EpsilonType, SymbolType > >, std::set < StateType > > & transition : transitions )
+ for ( const std::pair < const std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, std::set < StateType > > & transition : transitions )
if ( ( transition.second.find ( to ) != transition.second.end ( ) ) && transition.first.second.template is < SymbolType > ( ) )
transitionsToState[std::pair < StateType, SymbolType > ( transition.first.first, transition.first.second.template get < SymbolType > ( ) )].insert ( transition.second.begin ( ), transition.second.end ( ) );
@@ -547,7 +547,7 @@ std::map < std::pair < StateType, SymbolType >, std::set < StateType > > Epsilon
template<class SymbolType, class EpsilonType, class StateType >
bool EpsilonNFA < SymbolType, EpsilonType, StateType >::isEpsilonFree ( ) const {
- for ( const std::pair < const std::pair < StateType, std::variant < EpsilonType, SymbolType > >, std::set < StateType > > & transition : transitions )
+ for ( const std::pair < const std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, std::set < StateType > > & transition : transitions )
if ( transition.first.second.template is < EpsilonType > ( ) )
return false;
@@ -556,7 +556,7 @@ bool EpsilonNFA < SymbolType, EpsilonType, StateType >::isEpsilonFree ( ) const
template<class SymbolType, class EpsilonType, class StateType >
bool EpsilonNFA < SymbolType, EpsilonType, StateType >::isDeterministic ( ) const {
- for ( const std::pair < const std::pair < StateType, std::variant < EpsilonType, SymbolType > >, std::set < StateType > > & transition : transitions )
+ for ( const std::pair < const std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, std::set < StateType > > & transition : transitions )
if ( transition.second.size ( ) > 1 )
return false;
@@ -621,7 +621,7 @@ template<class SymbolType, class EpsilonType, class StateType >
void EpsilonNFA < SymbolType, EpsilonType, StateType >::parseTransition ( std::deque < sax::Token >::iterator & input, EpsilonNFA & automaton ) {
sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, "transition" );
StateType from = AutomatonFromXMLParser::parseTransitionFrom < StateType > ( input );
- std::variant < EpsilonType, SymbolType > inputVariant = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol < EpsilonType, SymbolType > ( input );
+ ext::variant < EpsilonType, SymbolType > inputVariant = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol < EpsilonType, SymbolType > ( input );
StateType to = AutomatonFromXMLParser::parseTransitionTo < StateType > ( input );
sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, "transition" );
@@ -672,7 +672,7 @@ template<class SymbolType, class EpsilonType, class StateType >
class ComponentConstraint< automaton::EpsilonNFA < SymbolType, EpsilonType, StateType >, SymbolType, automaton::InputAlphabet > {
public:
static bool used ( const automaton::EpsilonNFA < SymbolType, EpsilonType, StateType > & automaton, const SymbolType & symbol ) {
- for ( const std::pair < const std::pair < StateType, std::variant < EpsilonType, SymbolType > >, std::set < StateType > > & transition : automaton.getTransitions ( ) )
+ for ( const std::pair < const std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, std::set < StateType > > & transition : automaton.getTransitions ( ) )
if ( transition.first.second.template is < SymbolType > ( ) && ( transition.first.second.template get < SymbolType > ( ) == symbol ) )
return true;
@@ -697,7 +697,7 @@ public:
if ( automaton.getFinalStates ( ).count ( state ) )
return true;
- for ( const std::pair < const std::pair < StateType, std::variant < EpsilonType, SymbolType > >, std::set < StateType > > & transition : automaton.getTransitions ( ) )
+ for ( const std::pair < const std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, std::set < StateType > > & transition : automaton.getTransitions ( ) )
if ( ( transition.first.first == state ) || transition.second.count ( state ) )
return true;
diff --git a/alib2data/src/automaton/PDA/DPDA.h b/alib2data/src/automaton/PDA/DPDA.h
index 976f0a370e260c1eeddc3d137a5dbc06b9fb1ea7..e1c0c58e649d629a303ee0c963f01b44ce65f340 100644
--- a/alib2data/src/automaton/PDA/DPDA.h
+++ b/alib2data/src/automaton/PDA/DPDA.h
@@ -46,7 +46,7 @@ class InitialState;
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
class DPDA final : public AutomatonBase, public alib::Components < DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, std::tuple < InputAlphabet>, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < InitialSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
protected:
- std::map < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::pair < StateType, std::vector < PushdownStoreSymbolType > > > transitions;
+ std::map < std::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::pair < StateType, std::vector < PushdownStoreSymbolType > > > transitions;
public:
explicit DPDA ( std::set < StateType > states, std::set < InputSymbolType > inputAlphabet, std::set < PushdownStoreSymbolType > pushdownStoreSymbol, StateType initialState, PushdownStoreSymbolType initialPushdownSymbol, std::set < StateType > finalStates );
@@ -150,7 +150,7 @@ public:
* @throws AutomatonException when some part of the transition is not present
* in the DPDA (state, input symbol, stack symbol) or when transition already exists
*/
- bool addTransition ( StateType from, std::variant < EpsilonType, InputSymbolType > input, std::vector < PushdownStoreSymbolType > pop, StateType to, std::vector < PushdownStoreSymbolType > push );
+ bool addTransition ( StateType from, ext::variant < EpsilonType, InputSymbolType > input, std::vector < PushdownStoreSymbolType > pop, StateType to, std::vector < PushdownStoreSymbolType > push );
bool addTransition ( StateType from, InputSymbolType input, std::vector < PushdownStoreSymbolType > pop, StateType to, std::vector < PushdownStoreSymbolType > push );
@@ -161,7 +161,7 @@ public:
* @param transition transition to remove
* @throws AutomatonException when transition is not present in the DPDA
*/
- bool removeTransition ( const StateType & from, const std::variant < EpsilonType, InputSymbolType > & input, const std::vector < PushdownStoreSymbolType > & pop, const StateType & to, const std::vector < PushdownStoreSymbolType > & push );
+ bool removeTransition ( const StateType & from, const ext::variant < EpsilonType, InputSymbolType > & input, const std::vector < PushdownStoreSymbolType > & pop, const StateType & to, const std::vector < PushdownStoreSymbolType > & push );
bool removeTransition ( const StateType & from, const InputSymbolType & input, const std::vector < PushdownStoreSymbolType > & pop, const StateType & to, const std::vector < PushdownStoreSymbolType > & push );
@@ -170,17 +170,17 @@ public:
/**
* @return DPDA transitions
*/
- const std::map < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::pair < StateType, std::vector < PushdownStoreSymbolType > > > & getTransitions ( ) const;
+ const std::map < std::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::pair < StateType, std::vector < PushdownStoreSymbolType > > > & getTransitions ( ) const;
/**
* @return automaton transitions from state
*/
- std::map < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::pair < StateType, std::vector < PushdownStoreSymbolType > > > getTransitionsFromState ( const StateType & from ) const;
+ std::map < std::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::pair < StateType, std::vector < PushdownStoreSymbolType > > > getTransitionsFromState ( const StateType & from ) const;
/**
* @return automaton transitions to state
*/
- std::map < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::pair < StateType, std::vector < PushdownStoreSymbolType > > > getTransitionsToState ( const StateType & from ) const;
+ std::map < std::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::pair < StateType, std::vector < PushdownStoreSymbolType > > > getTransitionsToState ( const StateType & from ) const;
virtual int compare ( const ObjectBase & other ) const {
if ( std::type_index ( typeid ( * this ) ) == std::type_index ( typeid ( other ) ) ) return this->compare ( ( decltype ( * this ) )other );
@@ -223,10 +223,10 @@ public:
DPDA < > * res = new DPDA < > ( std::move ( states ), std::move ( alphabet ), std::move ( pushdownAlphabet ), std::move ( initialState ), std::move ( initialSymbol ), std::move ( finalStates ) );
- for ( std::pair < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::pair < StateType, std::vector < PushdownStoreSymbolType > > > && transition : std::make_moveable_map ( transitions ) ) {
+ for ( std::pair < std::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::pair < StateType, std::vector < PushdownStoreSymbolType > > > && transition : std::make_moveable_map ( transitions ) ) {
std::vector < DefaultSymbolType > pop = alphabet::SymbolNormalize::normalizeSymbols ( std::move ( std::get < 2 > ( transition.first ) ) );
DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( std::get < 0 > ( transition.first ) ) );
- std::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( std::get < 1 > ( transition.first ) ) );
+ ext::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( std::get < 1 > ( transition.first ) ) );
DefaultStateType to = AutomatonNormalize::normalizeState ( std::move ( transition.second.first ) );
std::vector < DefaultSymbolType > push = alphabet::SymbolNormalize::normalizeSymbols ( std::move ( transition.second.second ) );
@@ -257,7 +257,7 @@ AutomatonBase* DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, Sta
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-bool DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransition(StateType from, std::variant<EpsilonType, InputSymbolType> input, std::vector < PushdownStoreSymbolType > pop, StateType to, std::vector < PushdownStoreSymbolType > push) {
+bool DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransition(StateType from, ext::variant<EpsilonType, InputSymbolType> input, std::vector < PushdownStoreSymbolType > pop, StateType to, std::vector < PushdownStoreSymbolType > push) {
if (! getStates().count(from)) {
throw AutomatonException("State \"" + ext::to_string ( from ) + "\" doesn't exist.");
}
@@ -282,7 +282,7 @@ bool DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::
}
}
- std::tuple<StateType, std::variant<EpsilonType, InputSymbolType>, std::vector<PushdownStoreSymbolType> > key(std::move(from), std::move(input), std::move(pop));
+ std::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, std::vector<PushdownStoreSymbolType> > key(std::move(from), std::move(input), std::move(pop));
std::pair<StateType, std::vector<PushdownStoreSymbolType> > value = std::make_pair(std::move(to), std::move(push));
if (transitions.find(key) != transitions.end()) {
@@ -297,7 +297,7 @@ bool DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::
}
if(std::get<1>(key).template is<EpsilonType>()) {
- if(std::any_of(transitions.begin(), transitions.end(), [&](const std::pair<const std::tuple<StateType, std::variant<EpsilonType, InputSymbolType>, std::vector<PushdownStoreSymbolType> >, std::pair<StateType, std::vector<PushdownStoreSymbolType> > > & transition) {
+ if(std::any_of(transitions.begin(), transitions.end(), [&](const std::pair<const std::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, std::vector<PushdownStoreSymbolType> >, std::pair<StateType, std::vector<PushdownStoreSymbolType> > > & transition) {
if(std::get<0>(transition.first) == std::get<0>(key)) {
const std::vector<PushdownStoreSymbolType>& alpha = std::get<2>(transition.first);
const std::vector<PushdownStoreSymbolType>& beta = std::get<2>(key);
@@ -314,7 +314,7 @@ bool DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::
}))
throw AutomatonException("Conflicting transition");
} else {
- if(std::any_of(transitions.begin(), transitions.end(), [&](const std::pair<const std::tuple<StateType, std::variant<EpsilonType, InputSymbolType>, std::vector<PushdownStoreSymbolType> >, std::pair<StateType, std::vector<PushdownStoreSymbolType> > > & transition) {
+ if(std::any_of(transitions.begin(), transitions.end(), [&](const std::pair<const std::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, std::vector<PushdownStoreSymbolType> >, std::pair<StateType, std::vector<PushdownStoreSymbolType> > > & transition) {
if(std::get<0>(transition.first) == std::get<0>(key) && ( std::get<1>(transition.first) == std::get<1>(key) || std::get<1>(transition.first).template is<EpsilonType>() )) {
const std::vector<PushdownStoreSymbolType>& alpha = std::get<2>(transition.first);
const std::vector<PushdownStoreSymbolType>& beta = std::get<2>(key);
@@ -338,19 +338,19 @@ bool DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransition(StateType from, InputSymbolType input, std::vector < PushdownStoreSymbolType > pop, StateType to, std::vector < PushdownStoreSymbolType > push) {
- std::variant<EpsilonType, InputSymbolType> inputVariant(std::move(input));
+ ext::variant<EpsilonType, InputSymbolType> inputVariant(std::move(input));
return addTransition(std::move(from), std::move(inputVariant), std::move(pop), std::move(to), std::move(push));
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransition(StateType from, std::vector < PushdownStoreSymbolType > pop, StateType to, std::vector < PushdownStoreSymbolType > push) {
- auto inputVariant = std::variant<EpsilonType, InputSymbolType>::template from < EpsilonType > ( );
+ auto inputVariant = ext::variant<EpsilonType, InputSymbolType>::template from < EpsilonType > ( );
return addTransition(std::move(from), std::move(inputVariant), std::move(pop), std::move(to), std::move(push));
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-bool DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeTransition(const StateType& from, const std::variant<EpsilonType, InputSymbolType>& input, const std::vector < PushdownStoreSymbolType > & pop, const StateType& to, const std::vector < PushdownStoreSymbolType > & push) {
- std::tuple<StateType, std::variant<EpsilonType, InputSymbolType>, std::vector < PushdownStoreSymbolType > > key(from, input, pop);
+bool DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeTransition(const StateType& from, const ext::variant<EpsilonType, InputSymbolType>& input, const std::vector < PushdownStoreSymbolType > & pop, const StateType& to, const std::vector < PushdownStoreSymbolType > & push) {
+ std::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, std::vector < PushdownStoreSymbolType > > key(from, input, pop);
std::pair<StateType, std::vector < PushdownStoreSymbolType > > value = std::make_pair(to, push);
if (transitions.find(key) == transitions.end())
@@ -371,28 +371,28 @@ bool DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeTransition(const StateType& from, const InputSymbolType& input, const std::vector < PushdownStoreSymbolType > & pop, const StateType& to, const std::vector < PushdownStoreSymbolType > & push) {
- std::variant<EpsilonType, InputSymbolType > inputVariant(input);
+ ext::variant<EpsilonType, InputSymbolType > inputVariant(input);
return removeTransition(from, inputVariant, pop, to, push);
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeTransition(const StateType& from, const std::vector < PushdownStoreSymbolType > & pop, const StateType& to, const std::vector < PushdownStoreSymbolType > & push) {
- auto inputVariant = std::variant<EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
+ auto inputVariant = ext::variant<EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
return removeTransition(from, inputVariant, pop, to, push);
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-const std::map<std::tuple<StateType, std::variant<EpsilonType, InputSymbolType >, std::vector<PushdownStoreSymbolType> >, std::pair<StateType, std::vector<PushdownStoreSymbolType> > >& DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getTransitions() const {
+const std::map<std::tuple<StateType, ext::variant<EpsilonType, InputSymbolType >, std::vector<PushdownStoreSymbolType> >, std::pair<StateType, std::vector<PushdownStoreSymbolType> > >& DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getTransitions() const {
return transitions;
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-std::map<std::tuple<StateType, std::variant<EpsilonType, InputSymbolType>, std::vector<PushdownStoreSymbolType> >, std::pair<StateType, std::vector<PushdownStoreSymbolType> > > DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getTransitionsFromState(const StateType& from) const {
+std::map<std::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, std::vector<PushdownStoreSymbolType> >, std::pair<StateType, std::vector<PushdownStoreSymbolType> > > DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getTransitionsFromState(const StateType& from) const {
if( ! getStates().count(from) )
throw AutomatonException("State \"" + ext::to_string ( from ) + "\" doesn't exist");
- std::map<std::tuple<StateType, std::variant<EpsilonType, InputSymbolType>, std::vector<PushdownStoreSymbolType> >, std::pair<StateType, std::vector<PushdownStoreSymbolType> > > transitionsFromState;
- for (const std::pair<const std::tuple<StateType, std::variant<EpsilonType, InputSymbolType>, std::vector<PushdownStoreSymbolType> >, std::pair<StateType, std::vector<PushdownStoreSymbolType> > >& transition : transitions) {
+ std::map<std::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, std::vector<PushdownStoreSymbolType> >, std::pair<StateType, std::vector<PushdownStoreSymbolType> > > transitionsFromState;
+ for (const std::pair<const std::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, std::vector<PushdownStoreSymbolType> >, std::pair<StateType, std::vector<PushdownStoreSymbolType> > >& transition : transitions) {
if (std::get<0>(transition.first) == from) {
transitionsFromState.insert(std::make_pair(transition.first, transition.second));
}
@@ -402,12 +402,12 @@ std::map<std::tuple<StateType, std::variant<EpsilonType, InputSymbolType>, std::
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-std::map<std::tuple<StateType, std::variant<EpsilonType, InputSymbolType>, std::vector<PushdownStoreSymbolType> >, std::pair<StateType, std::vector<PushdownStoreSymbolType> > > DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getTransitionsToState(const StateType& to) const {
+std::map<std::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, std::vector<PushdownStoreSymbolType> >, std::pair<StateType, std::vector<PushdownStoreSymbolType> > > DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getTransitionsToState(const StateType& to) const {
if( ! getStates().count(to))
throw AutomatonException("State \"" + ext::to_string ( to ) + "\" doesn't exist");
- std::map<std::tuple<StateType, std::variant<EpsilonType, InputSymbolType>, std::vector<PushdownStoreSymbolType> >, std::pair<StateType, std::vector<PushdownStoreSymbolType> > > transitionsToState;
- for (const std::pair<const std::tuple<StateType, std::variant<EpsilonType, InputSymbolType>, std::vector<PushdownStoreSymbolType> >, std::pair<StateType, std::vector<PushdownStoreSymbolType> > >& transition : transitions) {
+ std::map<std::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, std::vector<PushdownStoreSymbolType> >, std::pair<StateType, std::vector<PushdownStoreSymbolType> > > transitionsToState;
+ for (const std::pair<const std::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, std::vector<PushdownStoreSymbolType> >, std::pair<StateType, std::vector<PushdownStoreSymbolType> > >& transition : transitions) {
if (transition.second.first == to) {
transitionsToState.insert(std::make_pair(transition.first, transition.second));
}
@@ -472,7 +472,7 @@ template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolTy
void DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::parseTransition(std::deque<sax::Token>::iterator& input, DPDA& automaton) {
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
StateType from = AutomatonFromXMLParser::parseTransitionFrom<StateType>(input);
- std::variant<EpsilonType, InputSymbolType> inputSymbol = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol<EpsilonType, InputSymbolType>(input);
+ ext::variant<EpsilonType, InputSymbolType> inputSymbol = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol<EpsilonType, InputSymbolType>(input);
std::vector<PushdownStoreSymbolType> pop = AutomatonFromXMLParser::parseTransitionPop<PushdownStoreSymbolType>(input);
StateType to = AutomatonFromXMLParser::parseTransitionTo<StateType>(input);
std::vector<PushdownStoreSymbolType> push = AutomatonFromXMLParser::parseTransitionPush<PushdownStoreSymbolType>(input);
@@ -527,7 +527,7 @@ template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolTy
class ComponentConstraint< automaton::DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, automaton::InputAlphabet > {
public:
static bool used ( const automaton::DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & automaton, const InputSymbolType & symbol ) {
- for (const std::pair<const std::tuple<StateType, std::variant<EpsilonType, InputSymbolType>, std::vector<PushdownStoreSymbolType> >, std::pair<StateType, std::vector<PushdownStoreSymbolType> > >& transition : automaton.getTransitions())
+ for (const std::pair<const std::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, std::vector<PushdownStoreSymbolType> >, std::pair<StateType, std::vector<PushdownStoreSymbolType> > >& transition : automaton.getTransitions())
if (std::get<1>(transition.first).template is<InputSymbolType>() && symbol == std::get<1>(transition.first).template get<InputSymbolType>())
return true;
@@ -549,7 +549,7 @@ public:
if(automaton.getInitialSymbol() == symbol)
return true;
- for (const std::pair<const std::tuple<StateType, std::variant<EpsilonType, InputSymbolType>, std::vector<PushdownStoreSymbolType> >, std::pair<StateType, std::vector<PushdownStoreSymbolType> > >& transition : automaton.getTransitions()) {
+ for (const std::pair<const std::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, std::vector<PushdownStoreSymbolType> >, std::pair<StateType, std::vector<PushdownStoreSymbolType> > >& transition : automaton.getTransitions()) {
const auto & popSymbols = std::get<2>(transition.first);
const auto & pushSymbols = transition.second.second;
if(std::contains(popSymbols.begin(), popSymbols.end(), symbol ) || std::contains(pushSymbols.begin(), pushSymbols.end(), symbol))
@@ -588,7 +588,7 @@ public:
if ( automaton.getFinalStates ( ).count ( state ) )
return true;
- for (const std::pair<const std::tuple<StateType, std::variant<EpsilonType, InputSymbolType>, std::vector<PushdownStoreSymbolType> >, std::pair<StateType, std::vector<PushdownStoreSymbolType> > >& transition : automaton.getTransitions())
+ for (const std::pair<const std::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, std::vector<PushdownStoreSymbolType> >, std::pair<StateType, std::vector<PushdownStoreSymbolType> > >& transition : automaton.getTransitions())
if ( state == std::get<0>(transition.first) || transition.second.first == state )
return true;
diff --git a/alib2data/src/automaton/PDA/NPDA.h b/alib2data/src/automaton/PDA/NPDA.h
index 69860da1d0dea1fc4c8cfd626702ec7defe19415..2a9d9138f0366ec46e9362c4ee3e480f00b340b1 100644
--- a/alib2data/src/automaton/PDA/NPDA.h
+++ b/alib2data/src/automaton/PDA/NPDA.h
@@ -42,7 +42,7 @@ class InitialState;
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
class NPDA final : public AutomatonBase, public alib::Components < NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < InitialSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
protected:
- std::map < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::set < std::pair < StateType, std::vector < PushdownStoreSymbolType > > > > transitions;
+ std::map < std::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::set < std::pair < StateType, std::vector < PushdownStoreSymbolType > > > > transitions;
public:
explicit NPDA ( std::set < StateType > states, std::set < InputSymbolType > inputAlphabet, std::set < PushdownStoreSymbolType > pushdownStoreSymbol, StateType initialState, PushdownStoreSymbolType initialPushdownSymbol, std::set < StateType > finalStates );
@@ -146,7 +146,7 @@ public:
* @throws AutomatonException when some part of the transition is not present
* in the NPDA (state, input symbol, stack symbol) or when transition already exists
*/
- bool addTransition ( StateType from, std::variant < EpsilonType, InputSymbolType > input, std::vector < PushdownStoreSymbolType > pop, StateType to, std::vector < PushdownStoreSymbolType > push );
+ bool addTransition ( StateType from, ext::variant < EpsilonType, InputSymbolType > input, std::vector < PushdownStoreSymbolType > pop, StateType to, std::vector < PushdownStoreSymbolType > push );
bool addTransition ( StateType from, InputSymbolType input, std::vector < PushdownStoreSymbolType > pop, StateType to, std::vector < PushdownStoreSymbolType > push );
@@ -158,7 +158,7 @@ public:
* @throws AutomatonException when some part of the transition is not present
* in the NPDA (state, input symbol, stack symbol) or when transition already exists
*/
- void addTransitions ( StateType from, std::variant < EpsilonType, InputSymbolType > input, std::vector < PushdownStoreSymbolType > pop, std::set < std::pair < StateType, std::vector < PushdownStoreSymbolType > > > targets );
+ void addTransitions ( StateType from, ext::variant < EpsilonType, InputSymbolType > input, std::vector < PushdownStoreSymbolType > pop, std::set < std::pair < StateType, std::vector < PushdownStoreSymbolType > > > targets );
void addTransitions ( StateType from, InputSymbolType input, std::vector < PushdownStoreSymbolType > pop, std::set < std::pair < StateType, std::vector < PushdownStoreSymbolType > > > targets );
@@ -169,7 +169,7 @@ public:
* @param transition transition to remove
* @throws AutomatonException when transition is not present in the NPDA
*/
- bool removeTransition ( const StateType & from, const std::variant < EpsilonType, InputSymbolType > & input, const std::vector < PushdownStoreSymbolType > & pop, const StateType & to, const std::vector < PushdownStoreSymbolType > & push );
+ bool removeTransition ( const StateType & from, const ext::variant < EpsilonType, InputSymbolType > & input, const std::vector < PushdownStoreSymbolType > & pop, const StateType & to, const std::vector < PushdownStoreSymbolType > & push );
bool removeTransition ( const StateType & from, const InputSymbolType & input, const std::vector < PushdownStoreSymbolType > & pop, const StateType & to, const std::vector < PushdownStoreSymbolType > & push );
@@ -178,7 +178,7 @@ public:
/**
* @return NPDA transitions
*/
- const std::map < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::set < std::pair < StateType, std::vector < PushdownStoreSymbolType > > > > & getTransitions ( ) const;
+ const std::map < std::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::set < std::pair < StateType, std::vector < PushdownStoreSymbolType > > > > & getTransitions ( ) const;
virtual int compare ( const ObjectBase & other ) const {
if ( std::type_index ( typeid ( * this ) ) == std::type_index ( typeid ( other ) ) ) return this->compare ( ( decltype ( * this ) )other );
@@ -221,14 +221,14 @@ public:
NPDA < > * res = new NPDA < > ( std::move ( states ), std::move ( alphabet ), std::move ( pushdownAlphabet ), std::move ( initialState ), std::move ( initialSymbol ), std::move ( finalStates ) );
- for ( std::pair < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::set < std::pair < StateType, std::vector < PushdownStoreSymbolType > > > > && transition : std::make_moveable_map ( transitions ) ) {
+ for ( std::pair < std::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::set < std::pair < StateType, std::vector < PushdownStoreSymbolType > > > > && transition : std::make_moveable_map ( transitions ) ) {
std::set < std::pair < DefaultStateType, std::vector < DefaultSymbolType > > > targets;
for ( std::pair < StateType, std::vector < PushdownStoreSymbolType > > && target : std::make_moveable_set ( transition.second ) )
targets.insert ( std::make_pair ( AutomatonNormalize::normalizeState ( std::move ( target.first ) ), alphabet::SymbolNormalize::normalizeSymbols ( std::move ( target.second ) ) ) );
std::vector < DefaultSymbolType > pop = alphabet::SymbolNormalize::normalizeSymbols ( std::move ( std::get < 2 > ( transition.first ) ) );
DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( std::get < 0 > ( transition.first ) ) );
- std::variant < DefaultEpsilonType, DefaultStateType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( std::get < 1 > ( transition.first ) ) );
+ ext::variant < DefaultEpsilonType, DefaultStateType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( std::get < 1 > ( transition.first ) ) );
res->addTransitions ( std::move ( from ), std::move ( input ), std::move ( pop ), std::move ( targets ) );
}
@@ -256,7 +256,7 @@ AutomatonBase* NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, Sta
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-bool NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransition(StateType from, std::variant < EpsilonType, InputSymbolType > input, std::vector<PushdownStoreSymbolType> pop, StateType to, std::vector<PushdownStoreSymbolType> push) {
+bool NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransition(StateType from, ext::variant < EpsilonType, InputSymbolType > input, std::vector<PushdownStoreSymbolType> pop, StateType to, std::vector<PushdownStoreSymbolType> push) {
if (! getStates().count(from))
throw AutomatonException("State \"" + ext::to_string ( from ) + "\" doesn't exist.");
@@ -274,7 +274,7 @@ bool NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::
if (! getPushdownStoreAlphabet().count(pushSymbol))
throw AutomatonException("Pushdown store symbol \"" + ext::to_string ( pushSymbol ) + "\" doesn't exist.");
- std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, std::vector<PushdownStoreSymbolType> > key(std::move(from), std::move(input), std::move(pop));
+ std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, std::vector<PushdownStoreSymbolType> > key(std::move(from), std::move(input), std::move(pop));
std::pair<StateType, std::vector<PushdownStoreSymbolType> > value = std::make_pair(std::move(to), std::move(push));
return transitions[std::move(key)].insert(std::move(value)).second;
@@ -282,18 +282,18 @@ bool NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransition(StateType from, InputSymbolType input, std::vector<PushdownStoreSymbolType> pop, StateType to, std::vector<PushdownStoreSymbolType> push) {
- std::variant < EpsilonType, InputSymbolType > inputVariant(std::move(input));
+ ext::variant < EpsilonType, InputSymbolType > inputVariant(std::move(input));
return addTransition(std::move(from), std::move(inputVariant), std::move(pop), std::move(to), std::move(push));
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransition(StateType from, std::vector<PushdownStoreSymbolType> pop, StateType to, std::vector<PushdownStoreSymbolType> push) {
- auto inputVariant = std::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
+ auto inputVariant = ext::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
return addTransition(std::move(from), std::move(inputVariant), std::move(pop), std::move(to), std::move(push));
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-void NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransitions ( StateType from, std::variant < EpsilonType, InputSymbolType > input, std::vector < PushdownStoreSymbolType > pop, std::set < std::pair < StateType, std::vector < PushdownStoreSymbolType > > > targets ) {
+void NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransitions ( StateType from, ext::variant < EpsilonType, InputSymbolType > input, std::vector < PushdownStoreSymbolType > pop, std::set < std::pair < StateType, std::vector < PushdownStoreSymbolType > > > targets ) {
if (! getStates().count(from))
throw AutomatonException("State \"" + ext::to_string ( from ) + "\" doesn't exist.");
@@ -313,26 +313,26 @@ void NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::
throw AutomatonException("Pushdown store symbol \"" + ext::to_string ( pushSymbol ) + "\" doesn't exist.");
}
- std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, std::vector<PushdownStoreSymbolType> > key(std::move(from), std::move(input), std::move(pop));
+ std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, std::vector<PushdownStoreSymbolType> > key(std::move(from), std::move(input), std::move(pop));
transitions [ std::move ( key ) ].insert ( std::make_moveable_set ( targets ).begin ( ), std::make_moveable_set ( targets ).end ( ) );
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
void NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransitions ( StateType from, InputSymbolType input, std::vector < PushdownStoreSymbolType > pop, std::set < std::pair < StateType, std::vector < PushdownStoreSymbolType > > > targets ) {
- std::variant < EpsilonType, InputSymbolType > inputVariant(std::move(input));
+ ext::variant < EpsilonType, InputSymbolType > inputVariant(std::move(input));
addTransitions ( std::move ( from ), std::move ( inputVariant ), std::move ( pop ), std::move ( targets ) );
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
void NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransitions ( StateType from, std::vector < PushdownStoreSymbolType > pop, std::set < std::pair < StateType, std::vector < PushdownStoreSymbolType > > > targets ) {
- auto inputVariant = std::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
+ auto inputVariant = ext::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
addTransitions ( std::move ( from ), std::move ( inputVariant ), std::move ( pop ), std::move ( targets ) );
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-bool NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeTransition(const StateType& from, const std::variant < EpsilonType, InputSymbolType > & input, const std::vector<PushdownStoreSymbolType>& pop, const StateType& to, const std::vector<PushdownStoreSymbolType>& push) {
- std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, std::vector<PushdownStoreSymbolType> > key(from, input, pop);
+bool NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeTransition(const StateType& from, const ext::variant < EpsilonType, InputSymbolType > & input, const std::vector<PushdownStoreSymbolType>& pop, const StateType& to, const std::vector<PushdownStoreSymbolType>& push) {
+ std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, std::vector<PushdownStoreSymbolType> > key(from, input, pop);
std::pair<StateType, std::vector < PushdownStoreSymbolType > > value = std::make_pair(to, push);
return transitions[key].erase(value);
@@ -340,18 +340,18 @@ bool NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeTransition(const StateType& from, const InputSymbolType& input, const std::vector<PushdownStoreSymbolType>& pop, const StateType& to, const std::vector<PushdownStoreSymbolType>& push) {
- std::variant < EpsilonType, InputSymbolType > inputVariant(input);
+ ext::variant < EpsilonType, InputSymbolType > inputVariant(input);
return removeTransition(from, inputVariant, pop, to, push);
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeTransition(const StateType& from, const std::vector<PushdownStoreSymbolType>& pop, const StateType& to, const std::vector<PushdownStoreSymbolType>& push) {
- auto inputVariant = std::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
+ auto inputVariant = ext::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
return removeTransition(from, inputVariant, pop, to, push);
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-const std::map<std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, std::vector<PushdownStoreSymbolType> >, std::set<std::pair<StateType, std::vector<PushdownStoreSymbolType> > > >& NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getTransitions() const {
+const std::map<std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, std::vector<PushdownStoreSymbolType> >, std::set<std::pair<StateType, std::vector<PushdownStoreSymbolType> > > >& NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getTransitions() const {
return transitions;
}
@@ -411,7 +411,7 @@ template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolTy
void NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::parseTransition(std::deque<sax::Token>::iterator& input, NPDA& automaton) {
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
StateType from = AutomatonFromXMLParser::parseTransitionFrom<StateType>(input);
- std::variant < EpsilonType, InputSymbolType > inputSymbol = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol < EpsilonType, InputSymbolType > ( input );
+ ext::variant < EpsilonType, InputSymbolType > inputSymbol = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol < EpsilonType, InputSymbolType > ( input );
std::vector<PushdownStoreSymbolType> pop = AutomatonFromXMLParser::parseTransitionPop<PushdownStoreSymbolType>(input);
StateType to = AutomatonFromXMLParser::parseTransitionTo<StateType>(input);
std::vector<PushdownStoreSymbolType> push = AutomatonFromXMLParser::parseTransitionPush<PushdownStoreSymbolType>(input);
@@ -468,7 +468,7 @@ template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolTy
class ComponentConstraint< automaton::NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, automaton::InputAlphabet > {
public:
static bool used ( const automaton::NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & automaton, const InputSymbolType & symbol ) {
- for (const std::pair<const std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, std::vector<PushdownStoreSymbolType> >, std::set<std::pair<StateType, std::vector<PushdownStoreSymbolType> > > >& transition : automaton.getTransitions())
+ for (const std::pair<const std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, std::vector<PushdownStoreSymbolType> >, std::set<std::pair<StateType, std::vector<PushdownStoreSymbolType> > > >& transition : automaton.getTransitions())
if (std::get<1>(transition.first).template is<InputSymbolType>() && symbol == std::get<1>(transition.first).template get<InputSymbolType>())
return true;
@@ -490,7 +490,7 @@ public:
if(automaton.getInitialSymbol() == symbol)
return true;
- for (const std::pair<const std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, std::vector<PushdownStoreSymbolType> >, std::set<std::pair<StateType, std::vector<PushdownStoreSymbolType> > > >& transition : automaton.getTransitions()) {
+ for (const std::pair<const std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, std::vector<PushdownStoreSymbolType> >, std::set<std::pair<StateType, std::vector<PushdownStoreSymbolType> > > >& transition : automaton.getTransitions()) {
for (const PushdownStoreSymbolType& popSymbol : std::get<2>(transition.first))
if (symbol == popSymbol)
return true;
@@ -532,7 +532,7 @@ public:
if ( automaton.getFinalStates ( ).count ( state ) )
return true;
- for (const std::pair<const std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, std::vector<PushdownStoreSymbolType> >, std::set<std::pair<StateType, std::vector<PushdownStoreSymbolType> > > >& transition : automaton.getTransitions()) {
+ for (const std::pair<const std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, std::vector<PushdownStoreSymbolType> >, std::set<std::pair<StateType, std::vector<PushdownStoreSymbolType> > > >& transition : automaton.getTransitions()) {
if (state == std::get<0>(transition.first))
return true;
for(const std::pair<StateType, std::vector<PushdownStoreSymbolType> >& target : transition.second)
diff --git a/alib2data/src/automaton/PDA/NPDTA.h b/alib2data/src/automaton/PDA/NPDTA.h
index 9cfe95bb37f7a526905cf4aa6928ac206cc87f1a..de0fcfaf19cd20bc18e6b362e6f9d19cd4fc7cca 100644
--- a/alib2data/src/automaton/PDA/NPDTA.h
+++ b/alib2data/src/automaton/PDA/NPDTA.h
@@ -43,7 +43,7 @@ class InitialState;
template < class InputSymbolType, class OutputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
class NPDTA final : public AutomatonBase, public alib::Components < NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, OutputSymbolType, std::tuple < OutputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < InitialSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
protected:
- std::map < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::set < std::tuple < StateType, std::vector < PushdownStoreSymbolType >, std::vector < OutputSymbolType > > > > transitions;
+ std::map < std::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::set < std::tuple < StateType, std::vector < PushdownStoreSymbolType >, std::vector < OutputSymbolType > > > > transitions;
public:
explicit NPDTA ( std::set < StateType > states, std::set < InputSymbolType > inputAlphabet, std::set < OutputSymbolType > outputAlphabet, std::set < PushdownStoreSymbolType > pushdownStoreSymbol, StateType initialState, PushdownStoreSymbolType initialPushdownSymbol, std::set < StateType > finalStates );
@@ -168,7 +168,7 @@ public:
* @throws AutomatonException when some part of the transition is not present
* in the NPDTA (state, input symbol, stack symbol, output symbol) or when transition already exists
*/
- bool addTransition ( StateType from, std::variant < EpsilonType, InputSymbolType > input, std::vector < PushdownStoreSymbolType > pop, StateType to, std::vector < PushdownStoreSymbolType > push, std::vector < OutputSymbolType > output );
+ bool addTransition ( StateType from, ext::variant < EpsilonType, InputSymbolType > input, std::vector < PushdownStoreSymbolType > pop, StateType to, std::vector < PushdownStoreSymbolType > push, std::vector < OutputSymbolType > output );
bool addTransition ( StateType from, InputSymbolType input, std::vector < PushdownStoreSymbolType > pop, StateType to, std::vector < PushdownStoreSymbolType > push, std::vector < OutputSymbolType > output );
@@ -180,7 +180,7 @@ public:
* @throws AutomatonException when some part of the transition is not present
* in the NPDTA (state, input symbol, stack symbol, output symbol) or when transition already exists
*/
- void addTransitions ( StateType from, std::variant < EpsilonType, InputSymbolType > input, std::vector < PushdownStoreSymbolType > pop, std::set < std::tuple < StateType, std::vector < PushdownStoreSymbolType >, std::vector < OutputSymbolType > > > targets );
+ void addTransitions ( StateType from, ext::variant < EpsilonType, InputSymbolType > input, std::vector < PushdownStoreSymbolType > pop, std::set < std::tuple < StateType, std::vector < PushdownStoreSymbolType >, std::vector < OutputSymbolType > > > targets );
void addTransitions ( StateType from, InputSymbolType input, std::vector < PushdownStoreSymbolType > pop, std::set < std::tuple < StateType, std::vector < PushdownStoreSymbolType >, std::vector < OutputSymbolType > > > targets );
@@ -191,7 +191,7 @@ public:
* @param transition transition to remove
* @throws AutomatonException when transition is not present in the NPDTA
*/
- bool removeTransition ( const StateType & from, const std::variant < EpsilonType, InputSymbolType > & input, const std::vector < PushdownStoreSymbolType > & pop, const StateType & to, const std::vector < PushdownStoreSymbolType > & push, const std::vector < OutputSymbolType > & output );
+ bool removeTransition ( const StateType & from, const ext::variant < EpsilonType, InputSymbolType > & input, const std::vector < PushdownStoreSymbolType > & pop, const StateType & to, const std::vector < PushdownStoreSymbolType > & push, const std::vector < OutputSymbolType > & output );
bool removeTransition ( const StateType & from, const InputSymbolType & input, const std::vector < PushdownStoreSymbolType > & pop, const StateType & to, const std::vector < PushdownStoreSymbolType > & push, const std::vector < OutputSymbolType > & output );
@@ -200,9 +200,9 @@ public:
/**
* @return NPDTA transitions
*/
- const std::map < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::set < std::tuple < StateType, std::vector < PushdownStoreSymbolType >, std::vector < OutputSymbolType > > > > & getTransitions ( ) const;
+ const std::map < std::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::set < std::tuple < StateType, std::vector < PushdownStoreSymbolType >, std::vector < OutputSymbolType > > > > & getTransitions ( ) const;
- std::map < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::tuple < StateType, std::vector < PushdownStoreSymbolType >, std::vector < OutputSymbolType > > > getTransitionsFromState ( const StateType & from ) const;
+ std::map < std::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::tuple < StateType, std::vector < PushdownStoreSymbolType >, std::vector < OutputSymbolType > > > getTransitionsFromState ( const StateType & from ) const;
virtual int compare ( const ObjectBase & other ) const {
if ( std::type_index ( typeid ( * this ) ) == std::type_index ( typeid ( other ) ) ) return this->compare ( ( decltype ( * this ) )other );
@@ -246,14 +246,14 @@ public:
NPDTA < > * res = new NPDTA < > ( std::move ( states ), std::move ( alphabet ), std::move ( pushdownAlphabet ), std::move ( outputAlphabet ), std::move ( initialState ), std::move ( initialSymbol ), std::move ( finalStates ) );
- for ( std::pair < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::set < std::tuple < StateType, std::vector < PushdownStoreSymbolType >, std::vector < OutputSymbolType > > > > && transition : std::make_moveable_map ( transitions ) ) {
+ for ( std::pair < std::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::set < std::tuple < StateType, std::vector < PushdownStoreSymbolType >, std::vector < OutputSymbolType > > > > && transition : std::make_moveable_map ( transitions ) ) {
std::set < std::tuple < DefaultStateType, std::vector < DefaultSymbolType >, std::vector < DefaultSymbolType > > > targets;
for ( std::tuple < StateType, std::vector < PushdownStoreSymbolType >, std::vector < OutputSymbolType > > && target : std::make_moveable_set ( transition.second ) )
targets.insert ( std::make_tuple ( AutomatonNormalize::normalizeState ( std::move ( std::get < 0 > ( target ) ) ), alphabet::SymbolNormalize::normalizeSymbols ( std::move ( std::get < 1 > ( target ) ) ), alphabet::SymbolNormalize::normalizeSymbols ( std::move ( std::get < 2 > ( target ) ) ) ) );
std::vector < DefaultSymbolType > pop = alphabet::SymbolNormalize::normalizeSymbols ( std::move ( std::get < 2 > ( transition.first ) ) );
DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( std::get < 0 > ( transition.first ) ) );
- std::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( std::get < 1 > ( transition.first ) ) );
+ ext::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( std::get < 1 > ( transition.first ) ) );
res->addTransitions ( std::move ( from ), std::move ( input ), std::move ( pop ), std::move ( targets ) );
}
@@ -281,7 +281,7 @@ AutomatonBase* NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownS
}
template < class InputSymbolType, class OutputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-bool NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransition(StateType from, std::variant < EpsilonType, InputSymbolType > input, std::vector<PushdownStoreSymbolType> pop, StateType to, std::vector<PushdownStoreSymbolType> push, std::vector < OutputSymbolType > output) {
+bool NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransition(StateType from, ext::variant < EpsilonType, InputSymbolType > input, std::vector<PushdownStoreSymbolType> pop, StateType to, std::vector<PushdownStoreSymbolType> push, std::vector < OutputSymbolType > output) {
if (!getStates().count(from)) {
throw AutomatonException("State \"" + ext::to_string ( from ) + "\" doesn't exist.");
}
@@ -312,7 +312,7 @@ bool NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbol
}
}
- std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, std::vector<PushdownStoreSymbolType> > key(std::move(from), std::move(input), std::move(pop));
+ std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, std::vector<PushdownStoreSymbolType> > key(std::move(from), std::move(input), std::move(pop));
std::tuple<StateType, std::vector<PushdownStoreSymbolType>, std::vector<OutputSymbolType> > value(std::move(to), std::move(push), std::move(output));
return transitions[std::move(key)].insert(std::move(value)).second;
@@ -320,18 +320,18 @@ bool NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbol
template < class InputSymbolType, class OutputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransition(StateType from, InputSymbolType input, std::vector<PushdownStoreSymbolType> pop, StateType to, std::vector<PushdownStoreSymbolType> push, std::vector < OutputSymbolType > output) {
- std::variant < EpsilonType, InputSymbolType > inputVariant(std::move(input));
+ ext::variant < EpsilonType, InputSymbolType > inputVariant(std::move(input));
return addTransition(std::move(from), std::move(inputVariant), std::move(pop), std::move(to), std::move(push), std::move(output));
}
template < class InputSymbolType, class OutputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransition(StateType from, std::vector<PushdownStoreSymbolType> pop, StateType to, std::vector<PushdownStoreSymbolType> push, std::vector < OutputSymbolType > output) {
- auto inputVariant = std::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
+ auto inputVariant = ext::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
return addTransition(std::move(from), std::move(inputVariant), std::move(pop), std::move(to), std::move(push), std::move(output));
}
template < class InputSymbolType, class OutputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-void NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransitions ( StateType from, std::variant < EpsilonType, InputSymbolType > input, std::vector<PushdownStoreSymbolType> pop, std::set < std::tuple < StateType, std::vector < PushdownStoreSymbolType >, std::vector < OutputSymbolType > > > targets ) {
+void NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransitions ( StateType from, ext::variant < EpsilonType, InputSymbolType > input, std::vector<PushdownStoreSymbolType> pop, std::set < std::tuple < StateType, std::vector < PushdownStoreSymbolType >, std::vector < OutputSymbolType > > > targets ) {
if ( ! getStates ( ).count ( from ) )
throw AutomatonException ( "State \"" + ext::to_string ( from ) + "\" doesn't exist." );
@@ -355,26 +355,26 @@ void NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbol
throw AutomatonException ( "Output symbol \"" + ext::to_string ( outputSymbol ) + "\" doesn't exist." );
}
- std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > > key ( std::move ( from ), std::move ( input ), std::move ( pop ) );
+ std::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > > key ( std::move ( from ), std::move ( input ), std::move ( pop ) );
transitions [ std::move ( key ) ].insert ( std::make_moveable_set ( targets ).begin ( ), std::make_moveable_set ( targets ).end ( ) );
}
template < class InputSymbolType, class OutputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
void NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransitions ( StateType from, InputSymbolType input, std::vector<PushdownStoreSymbolType> pop, std::set < std::tuple < StateType, std::vector < PushdownStoreSymbolType >, std::vector < OutputSymbolType > > > targets ) {
- std::variant < EpsilonType, InputSymbolType > inputVariant ( std::move ( input ) );
+ ext::variant < EpsilonType, InputSymbolType > inputVariant ( std::move ( input ) );
addTransition ( std::move ( from ), std::move ( inputVariant ), std::move ( pop ), std::move ( targets ) );
}
template < class InputSymbolType, class OutputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
void NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransitions ( StateType from, std::vector<PushdownStoreSymbolType> pop, std::set < std::tuple < StateType, std::vector < PushdownStoreSymbolType >, std::vector < OutputSymbolType > > > targets ) {
- auto inputVariant = std::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
+ auto inputVariant = ext::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
addTransition ( std::move ( from ), std::move ( inputVariant ), std::move ( pop ), std::move ( targets ) );
}
template < class InputSymbolType, class OutputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-bool NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeTransition(const StateType& from, const std::variant < EpsilonType, InputSymbolType >& input, const std::vector < PushdownStoreSymbolType > & pop, const StateType& to, const std::vector<PushdownStoreSymbolType>& push, const std::vector < OutputSymbolType > & output) {
- std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, std::vector<PushdownStoreSymbolType> > key(from, input, pop);
+bool NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeTransition(const StateType& from, const ext::variant < EpsilonType, InputSymbolType >& input, const std::vector < PushdownStoreSymbolType > & pop, const StateType& to, const std::vector<PushdownStoreSymbolType>& push, const std::vector < OutputSymbolType > & output) {
+ std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, std::vector<PushdownStoreSymbolType> > key(from, input, pop);
std::tuple<StateType, std::vector<PushdownStoreSymbolType>, std::vector < OutputSymbolType > > value(to, push, output);
return transitions[key].erase(value);
@@ -382,27 +382,27 @@ bool NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbol
template < class InputSymbolType, class OutputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeTransition(const StateType& from, const InputSymbolType& input, const std::vector<PushdownStoreSymbolType>& pop, const StateType& to, const std::vector<PushdownStoreSymbolType>& push, const std::vector < OutputSymbolType > & output) {
- std::variant < EpsilonType, InputSymbolType > inputVariant(input);
+ ext::variant < EpsilonType, InputSymbolType > inputVariant(input);
return removeTransition(from, inputVariant, pop, to, push, output);
}
template < class InputSymbolType, class OutputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeTransition(const StateType& from, const std::vector<PushdownStoreSymbolType>& pop, const StateType& to, const std::vector<PushdownStoreSymbolType>& push, const std::vector < OutputSymbolType > & output) {
- auto inputVariant = std::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
+ auto inputVariant = ext::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
return removeTransition(from, inputVariant, pop, to, push, output);
}
template < class InputSymbolType, class OutputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-const std::map<std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, std::vector<PushdownStoreSymbolType> >, std::set<std::tuple<StateType, std::vector<PushdownStoreSymbolType>, std::vector < OutputSymbolType > > > >& NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getTransitions() const {
+const std::map<std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, std::vector<PushdownStoreSymbolType> >, std::set<std::tuple<StateType, std::vector<PushdownStoreSymbolType>, std::vector < OutputSymbolType > > > >& NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getTransitions() const {
return transitions;
}
template < class InputSymbolType, class OutputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-std::map < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::tuple < StateType, std::vector < PushdownStoreSymbolType >, std::vector < OutputSymbolType > > > NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getTransitionsFromState ( const StateType & from ) const {
+std::map < std::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::tuple < StateType, std::vector < PushdownStoreSymbolType >, std::vector < OutputSymbolType > > > NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getTransitionsFromState ( const StateType & from ) const {
if( !getStates().count(from))
throw AutomatonException("State \"" + ext::to_string ( from ) + "\" doesn't exist");
- std::map < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::tuple < StateType, std::vector < PushdownStoreSymbolType >, std::vector < PushdownStoreSymbolType > > > transitionsFromState;
+ std::map < std::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::tuple < StateType, std::vector < PushdownStoreSymbolType >, std::vector < PushdownStoreSymbolType > > > transitionsFromState;
for ( auto transition: transitions ) {
for ( auto iter: transition.second ) {
if ( std::get<0>(transition.first) == from ) {
@@ -474,7 +474,7 @@ template < class InputSymbolType, class OutputSymbolType, class EpsilonType, cla
void NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::parseTransition(std::deque<sax::Token>::iterator& input, NPDTA& automaton) {
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
StateType from = AutomatonFromXMLParser::parseTransitionFrom<StateType>(input);
- std::variant < EpsilonType, InputSymbolType > inputSymbol = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol<EpsilonType, InputSymbolType>(input);
+ ext::variant < EpsilonType, InputSymbolType > inputSymbol = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol<EpsilonType, InputSymbolType>(input);
std::vector<PushdownStoreSymbolType> pop = AutomatonFromXMLParser::parseTransitionPop<PushdownStoreSymbolType>(input);
StateType to = AutomatonFromXMLParser::parseTransitionTo<StateType>(input);
std::vector<PushdownStoreSymbolType> push = AutomatonFromXMLParser::parseTransitionPush<PushdownStoreSymbolType>(input);
@@ -534,7 +534,7 @@ template < class InputSymbolType, class OutputSymbolType, class EpsilonType, cla
class ComponentConstraint< automaton::NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, automaton::InputAlphabet > {
public:
static bool used ( const automaton::NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & automaton, const InputSymbolType & symbol ) {
- for (const std::pair<const std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, std::vector<PushdownStoreSymbolType> >, std::set<std::tuple<StateType, std::vector<PushdownStoreSymbolType>, std::vector < OutputSymbolType > > > >& transition : automaton.getTransitions())
+ for (const std::pair<const std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, std::vector<PushdownStoreSymbolType> >, std::set<std::tuple<StateType, std::vector<PushdownStoreSymbolType>, std::vector < OutputSymbolType > > > >& transition : automaton.getTransitions())
if (std::get<1>(transition.first).template is < InputSymbolType >() && symbol == std::get<1>(transition.first).template get < InputSymbolType >())
return true;
@@ -553,7 +553,7 @@ template < class InputSymbolType, class OutputSymbolType, class EpsilonType, cla
class ComponentConstraint< automaton::NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, OutputSymbolType, automaton::OutputAlphabet > {
public:
static bool used ( const automaton::NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & automaton, const OutputSymbolType & symbol ) {
- for (const std::pair<const std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, std::vector<PushdownStoreSymbolType> >, std::set<std::tuple<StateType, std::vector<PushdownStoreSymbolType>, std::vector < OutputSymbolType > > > >& transition : automaton.getTransitions())
+ for (const std::pair<const std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, std::vector<PushdownStoreSymbolType> >, std::set<std::tuple<StateType, std::vector<PushdownStoreSymbolType>, std::vector < OutputSymbolType > > > >& transition : automaton.getTransitions())
for(const std::tuple<StateType, std::vector<PushdownStoreSymbolType>, std::vector < OutputSymbolType > >& target : transition.second)
if (std::find(std::get<2>(target).begin(), std::get<2>(target).end(), symbol) != std::get<2>(target).end())
return true;
@@ -576,7 +576,7 @@ public:
if(automaton.getInitialSymbol() == symbol)
return true;
- for (const std::pair<const std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, std::vector<PushdownStoreSymbolType> >, std::set<std::tuple<StateType, std::vector<PushdownStoreSymbolType>, std::vector < OutputSymbolType > > > >& transition : automaton.getTransitions()) {
+ for (const std::pair<const std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, std::vector<PushdownStoreSymbolType> >, std::set<std::tuple<StateType, std::vector<PushdownStoreSymbolType>, std::vector < OutputSymbolType > > > >& transition : automaton.getTransitions()) {
for (const PushdownStoreSymbolType& popSymbol : std::get<2>(transition.first))
if (symbol == popSymbol)
return true;
@@ -618,7 +618,7 @@ public:
if ( automaton.getFinalStates ( ).count ( state ) )
return true;
- for (const std::pair<const std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, std::vector<PushdownStoreSymbolType> >, std::set<std::tuple<StateType, std::vector<PushdownStoreSymbolType>, std::vector < OutputSymbolType > > > >& transition : automaton.getTransitions()) {
+ for (const std::pair<const std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, std::vector<PushdownStoreSymbolType> >, std::set<std::tuple<StateType, std::vector<PushdownStoreSymbolType>, std::vector < OutputSymbolType > > > >& transition : automaton.getTransitions()) {
if (state == std::get<0>(transition.first))
return true;
diff --git a/alib2data/src/automaton/PDA/RealTimeHeightDeterministicDPDA.h b/alib2data/src/automaton/PDA/RealTimeHeightDeterministicDPDA.h
index f65ec876fc7e1944919624dfac02bbf8dcdc882e..daea9a38109faf69d82ddf1bacf60747fd9bb814 100644
--- a/alib2data/src/automaton/PDA/RealTimeHeightDeterministicDPDA.h
+++ b/alib2data/src/automaton/PDA/RealTimeHeightDeterministicDPDA.h
@@ -42,9 +42,9 @@ class InitialState;
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
class RealTimeHeightDeterministicDPDA final : public AutomatonBase, public alib::Components < RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
protected:
- std::map < std::pair < StateType, std::variant < EpsilonType, InputSymbolType > >, std::pair < StateType, PushdownStoreSymbolType > > callTransitions;
- std::map < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, StateType > returnTransitions;
- std::map < std::pair < StateType, std::variant < EpsilonType, InputSymbolType > >, StateType > localTransitions;
+ std::map < std::pair < StateType, ext::variant < EpsilonType, InputSymbolType > >, std::pair < StateType, PushdownStoreSymbolType > > callTransitions;
+ std::map < std::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, StateType > returnTransitions;
+ std::map < std::pair < StateType, ext::variant < EpsilonType, InputSymbolType > >, StateType > localTransitions;
public:
explicit RealTimeHeightDeterministicDPDA ( std::set < StateType > states, std::set < InputSymbolType > inputAlphabet, std::set < PushdownStoreSymbolType > pushdownStoreSymbol, StateType initialState, PushdownStoreSymbolType bottomOfTheStackSymbol, std::set < StateType > finalStates );
@@ -149,7 +149,7 @@ public:
* @param next next state
* @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
*/
- bool addCallTransition ( StateType current, std::variant < EpsilonType, InputSymbolType > input, StateType next, PushdownStoreSymbolType push );
+ bool addCallTransition ( StateType current, ext::variant < EpsilonType, InputSymbolType > input, StateType next, PushdownStoreSymbolType push );
bool addCallTransition ( StateType current, StateType next, PushdownStoreSymbolType push );
bool addCallTransition ( StateType current, InputSymbolType input, StateType next, PushdownStoreSymbolType push );
@@ -160,7 +160,7 @@ public:
* @param next next state
* @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
*/
- bool addReturnTransition ( StateType current, std::variant < EpsilonType, InputSymbolType > input, PushdownStoreSymbolType pop, StateType next );
+ bool addReturnTransition ( StateType current, ext::variant < EpsilonType, InputSymbolType > input, PushdownStoreSymbolType pop, StateType next );
bool addReturnTransition ( StateType current, PushdownStoreSymbolType pop, StateType next );
bool addReturnTransition ( StateType current, InputSymbolType input, PushdownStoreSymbolType pop, StateType next );
@@ -171,7 +171,7 @@ public:
* @param next next state
* @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
*/
- bool addLocalTransition ( StateType current, std::variant < EpsilonType, InputSymbolType > input, StateType next );
+ bool addLocalTransition ( StateType current, ext::variant < EpsilonType, InputSymbolType > input, StateType next );
bool addLocalTransition ( StateType current, StateType next );
bool addLocalTransition ( StateType current, InputSymbolType input, StateType next );
@@ -180,7 +180,7 @@ public:
* @param transition transition to remove
* @throws AutomatonException when transition doesn't exists.
*/
- bool removeCallTransition ( const StateType & current, const std::variant < EpsilonType, InputSymbolType > & input, const StateType & next, const PushdownStoreSymbolType & push );
+ bool removeCallTransition ( const StateType & current, const ext::variant < EpsilonType, InputSymbolType > & input, const StateType & next, const PushdownStoreSymbolType & push );
bool removeCallTransition ( const StateType & current, const StateType & next, const PushdownStoreSymbolType & push );
bool removeCallTransition ( const StateType & current, const InputSymbolType & input, const StateType & next, const PushdownStoreSymbolType & push );
@@ -189,7 +189,7 @@ public:
* @param transition transition to remove
* @throws AutomatonException when transition doesn't exists.
*/
- bool removeReturnTransition ( const StateType & current, const std::variant < EpsilonType, InputSymbolType > & input, const PushdownStoreSymbolType & pop, const StateType & next );
+ bool removeReturnTransition ( const StateType & current, const ext::variant < EpsilonType, InputSymbolType > & input, const PushdownStoreSymbolType & pop, const StateType & next );
bool removeReturnTransition ( const StateType & current, const PushdownStoreSymbolType & pop, const StateType & next );
bool removeReturnTransition ( const StateType & current, const InputSymbolType & input, const PushdownStoreSymbolType & pop, const StateType & next );
@@ -198,15 +198,15 @@ public:
* @param transition transition to remove
* @throws AutomatonException when transition doesn't exists.
*/
- bool removeLocalTransition ( const StateType & current, const std::variant < EpsilonType, InputSymbolType > & input, const StateType & next );
+ bool removeLocalTransition ( const StateType & current, const ext::variant < EpsilonType, InputSymbolType > & input, const StateType & next );
bool removeLocalTransition ( const StateType & current, const StateType & next );
bool removeLocalTransition ( const StateType & current, const InputSymbolType & input, const StateType & next );
- const std::map < std::pair < StateType, std::variant < EpsilonType, InputSymbolType > >, std::pair < StateType, PushdownStoreSymbolType > > & getCallTransitions ( ) const;
+ const std::map < std::pair < StateType, ext::variant < EpsilonType, InputSymbolType > >, std::pair < StateType, PushdownStoreSymbolType > > & getCallTransitions ( ) const;
- const std::map < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, StateType > & getReturnTransitions ( ) const;
+ const std::map < std::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, StateType > & getReturnTransitions ( ) const;
- const std::map < std::pair < StateType, std::variant < EpsilonType, InputSymbolType > >, StateType > & getLocalTransitions ( ) const;
+ const std::map < std::pair < StateType, ext::variant < EpsilonType, InputSymbolType > >, StateType > & getLocalTransitions ( ) const;
virtual int compare ( const ObjectBase & other ) const {
if ( std::type_index ( typeid ( * this ) ) == std::type_index ( typeid ( other ) ) ) return this->compare ( ( decltype ( * this ) )other );
@@ -249,31 +249,31 @@ public:
RealTimeHeightDeterministicDPDA < > * res = new RealTimeHeightDeterministicDPDA < > ( std::move ( states ), std::move ( alphabet ), std::move ( pushdownAlphabet ), std::move ( initialState ), std::move ( bottomSymbol ), std::move ( finalStates ) );
- for ( std::pair < std::pair < StateType, std::variant < EpsilonType, InputSymbolType > >, std::pair < StateType, PushdownStoreSymbolType > > && transition : std::make_moveable_map ( callTransitions ) ) {
+ for ( std::pair < std::pair < StateType, ext::variant < EpsilonType, InputSymbolType > >, std::pair < StateType, PushdownStoreSymbolType > > && transition : std::make_moveable_map ( callTransitions ) ) {
DefaultStateType to = AutomatonNormalize::normalizeState ( std::move ( transition.second.first ) );
DefaultSymbolType push = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( transition.second.second ) );
DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) );
- std::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( transition.first.second ) );
+ ext::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( transition.first.second ) );
res->addCallTransition ( std::move ( from ), std::move ( input ), std::move ( to ), std::move ( push ) );
}
- for ( std::pair < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, StateType > && transition : std::make_moveable_map ( returnTransitions ) ) {
+ for ( std::pair < std::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, StateType > && transition : std::make_moveable_map ( returnTransitions ) ) {
DefaultStateType to = AutomatonNormalize::normalizeState ( std::move ( transition.second ) );
DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( std::get < 0 > ( transition.first ) ) );
- std::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( std::get < 1 > ( transition.first ) ) );
+ ext::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( std::get < 1 > ( transition.first ) ) );
DefaultSymbolType pop = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( std::get < 2 > ( transition.first ) ) );
res->addReturnTransition ( std::move ( from ), std::move ( input ), std::move ( pop ), std::move ( to ) );
}
- for ( std::pair < std::pair < StateType, std::variant < EpsilonType, InputSymbolType > >, StateType > && transition : std::make_moveable_map ( localTransitions ) ) {
+ for ( std::pair < std::pair < StateType, ext::variant < EpsilonType, InputSymbolType > >, StateType > && transition : std::make_moveable_map ( localTransitions ) ) {
DefaultStateType to = AutomatonNormalize::normalizeState ( std::move ( transition.second ) );
DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) );
- std::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( transition.first.second ) );
+ ext::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( transition.first.second ) );
res->addLocalTransition ( std::move ( from ), std::move ( input ), std::move ( to ) );
}
@@ -300,7 +300,7 @@ AutomatonBase* RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, P
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addCallTransition(StateType from, std::variant < EpsilonType, InputSymbolType > input, StateType to, PushdownStoreSymbolType push) {
+bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addCallTransition(StateType from, ext::variant < EpsilonType, InputSymbolType > input, StateType to, PushdownStoreSymbolType push) {
if (!getStates().count(from)) {
throw AutomatonException("State \"" + ext::to_string ( from ) + "\" doesn't exist.");
}
@@ -320,7 +320,7 @@ bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownSto
if(getBottomOfTheStackSymbol() == push)
throw AutomatonException("Pushdown store symbol \"" + ext::to_string ( push ) + "\" is bottom of the stack.");
- std::pair<StateType, std::variant < EpsilonType, InputSymbolType >> key(std::move(from), std::move(input));
+ std::pair<StateType, ext::variant < EpsilonType, InputSymbolType >> key(std::move(from), std::move(input));
std::pair<StateType, PushdownStoreSymbolType> value = std::make_pair(std::move(to), std::move(push));
if(callTransitions.find(key) != callTransitions.end() && callTransitions.find(key)->second == value)
@@ -358,18 +358,18 @@ bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownSto
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addCallTransition(StateType from, StateType to, PushdownStoreSymbolType push) {
- auto inputVariant = std::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
+ auto inputVariant = ext::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
return addCallTransition(std::move(from), std::move(inputVariant), std::move(to), std::move(push));
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addCallTransition(StateType from, InputSymbolType input, StateType to, PushdownStoreSymbolType push) {
- std::variant < EpsilonType, InputSymbolType > inputVariant(std::move(input));
+ ext::variant < EpsilonType, InputSymbolType > inputVariant(std::move(input));
return addCallTransition(std::move(from), std::move(inputVariant), std::move(to), std::move(push));
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addReturnTransition(StateType from, std::variant < EpsilonType, InputSymbolType > input, PushdownStoreSymbolType pop, StateType to) {
+bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addReturnTransition(StateType from, ext::variant < EpsilonType, InputSymbolType > input, PushdownStoreSymbolType pop, StateType to) {
if (!getStates().count(from)) {
throw AutomatonException("State \"" + ext::to_string ( from ) + "\" doesn't exist.");
}
@@ -386,7 +386,7 @@ bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownSto
throw AutomatonException("Pushdown store symbol \"" + ext::to_string ( pop ) + "\" doesn't exist.");
}
- std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType> key(std::move(from), std::move(input), std::move(pop));
+ std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType> key(std::move(from), std::move(input), std::move(pop));
if(returnTransitions.find(key) != returnTransitions.end() && returnTransitions.find(key)->second == to)
return false;
@@ -423,18 +423,18 @@ bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownSto
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addReturnTransition(StateType from, PushdownStoreSymbolType pop, StateType to) {
- auto inputVariant = std::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
+ auto inputVariant = ext::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
return addReturnTransition(std::move(from), std::move(inputVariant), std::move(pop), std::move(to));
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addReturnTransition(StateType from, InputSymbolType input, PushdownStoreSymbolType pop, StateType to) {
- std::variant < EpsilonType, InputSymbolType > inputVariant(std::move(input));
+ ext::variant < EpsilonType, InputSymbolType > inputVariant(std::move(input));
return addReturnTransition(std::move(from), std::move(inputVariant), std::move(pop), std::move(to));
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addLocalTransition(StateType from, std::variant < EpsilonType, InputSymbolType > input, StateType to) {
+bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addLocalTransition(StateType from, ext::variant < EpsilonType, InputSymbolType > input, StateType to) {
if (!getStates().count(from)) {
throw AutomatonException("State \"" + ext::to_string ( from ) + "\" doesn't exist.");
}
@@ -447,7 +447,7 @@ bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownSto
throw AutomatonException("State \"" + ext::to_string ( to ) + "\" doesn't exist.");
}
- std::pair<StateType, std::variant < EpsilonType, InputSymbolType >> key(std::move(from), std::move(input));
+ std::pair<StateType, ext::variant < EpsilonType, InputSymbolType >> key(std::move(from), std::move(input));
if(localTransitions.find(key) != localTransitions.end() && localTransitions.find(key)->second == to)
return false;
@@ -484,19 +484,19 @@ bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownSto
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addLocalTransition(StateType from, StateType to) {
- auto inputVariant = std::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
+ auto inputVariant = ext::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
return addLocalTransition(std::move(from), std::move(inputVariant), std::move(to));
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addLocalTransition(StateType from, InputSymbolType input, StateType to) {
- std::variant < EpsilonType, InputSymbolType > inputVariant(std::move(input));
+ ext::variant < EpsilonType, InputSymbolType > inputVariant(std::move(input));
return addLocalTransition(std::move(from), std::move(inputVariant), std::move(to));
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeCallTransition(const StateType& from, const std::variant < EpsilonType, InputSymbolType >& input, const StateType& to, const PushdownStoreSymbolType& push) {
- std::pair<StateType, std::variant < EpsilonType, InputSymbolType >> key(from, input);
+bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeCallTransition(const StateType& from, const ext::variant < EpsilonType, InputSymbolType >& input, const StateType& to, const PushdownStoreSymbolType& push) {
+ std::pair<StateType, ext::variant < EpsilonType, InputSymbolType >> key(from, input);
std::pair<StateType, PushdownStoreSymbolType> value = std::make_pair(to, push);
if (callTransitions.find(key) == callTransitions.end())
@@ -511,19 +511,19 @@ bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownSto
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeCallTransition(const StateType& from, const StateType& to, const PushdownStoreSymbolType& push) {
- auto inputVariant = std::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
+ auto inputVariant = ext::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
return removeCallTransition(from, inputVariant, to, push);
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeCallTransition(const StateType& from, const InputSymbolType& input, const StateType& to, const PushdownStoreSymbolType& push) {
- std::variant < EpsilonType, InputSymbolType > inputVariant(input);
+ ext::variant < EpsilonType, InputSymbolType > inputVariant(input);
return removeCallTransition(from, inputVariant, to, push);
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeReturnTransition(const StateType& from, const std::variant < EpsilonType, InputSymbolType >& input, const PushdownStoreSymbolType& pop, const StateType& to) {
- std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType> key(from, input, pop);
+bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeReturnTransition(const StateType& from, const ext::variant < EpsilonType, InputSymbolType >& input, const PushdownStoreSymbolType& pop, const StateType& to) {
+ std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType> key(from, input, pop);
if (returnTransitions.find(key) == returnTransitions.end())
return false;
@@ -537,19 +537,19 @@ bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownSto
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeReturnTransition(const StateType& from, const PushdownStoreSymbolType& pop, const StateType& to) {
- auto inputVariant = std::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
+ auto inputVariant = ext::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
return removeReturnTransition(from, inputVariant, pop, to);
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeReturnTransition(const StateType& from, const InputSymbolType& input, const PushdownStoreSymbolType& pop, const StateType& to) {
- std::variant < EpsilonType, InputSymbolType > inputVariant(input);
+ ext::variant < EpsilonType, InputSymbolType > inputVariant(input);
return removeReturnTransition(from, inputVariant, pop, to);
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeLocalTransition(const StateType& from, const std::variant < EpsilonType, InputSymbolType >& input, const StateType& to) {
- std::pair<StateType, std::variant < EpsilonType, InputSymbolType >> key(from, input);
+bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeLocalTransition(const StateType& from, const ext::variant < EpsilonType, InputSymbolType >& input, const StateType& to) {
+ std::pair<StateType, ext::variant < EpsilonType, InputSymbolType >> key(from, input);
if (localTransitions.find(key) == localTransitions.end())
return false;
@@ -563,28 +563,28 @@ bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownSto
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeLocalTransition(const StateType& from, const StateType& to) {
- auto inputVariant = std::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
+ auto inputVariant = ext::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
return removeLocalTransition(from, inputVariant, to);
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeLocalTransition(const StateType& from, const InputSymbolType& input, const StateType& to) {
- std::variant < EpsilonType, InputSymbolType > inputVariant(input);
+ ext::variant < EpsilonType, InputSymbolType > inputVariant(input);
return removeLocalTransition(from, inputVariant, to);
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-const std::map<std::pair<StateType, std::variant < EpsilonType, InputSymbolType >>, std::pair<StateType, PushdownStoreSymbolType> >& RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getCallTransitions() const {
+const std::map<std::pair<StateType, ext::variant < EpsilonType, InputSymbolType >>, std::pair<StateType, PushdownStoreSymbolType> >& RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getCallTransitions() const {
return callTransitions;
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-const std::map<std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, StateType>& RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getReturnTransitions() const {
+const std::map<std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, StateType>& RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getReturnTransitions() const {
return returnTransitions;
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-const std::map<std::pair<StateType, std::variant < EpsilonType, InputSymbolType >>, StateType>& RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getLocalTransitions() const {
+const std::map<std::pair<StateType, ext::variant < EpsilonType, InputSymbolType >>, StateType>& RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getLocalTransitions() const {
return localTransitions;
}
@@ -647,7 +647,7 @@ void RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownSto
if(sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, "callTransition")) {
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "callTransition");
StateType from = AutomatonFromXMLParser::parseTransitionFrom<StateType>(input);
- std::variant < EpsilonType, InputSymbolType > inputSymbol = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol<EpsilonType,InputSymbolType>(input);
+ ext::variant < EpsilonType, InputSymbolType > inputSymbol = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol<EpsilonType,InputSymbolType>(input);
StateType to = AutomatonFromXMLParser::parseTransitionTo<StateType>(input);
PushdownStoreSymbolType push = AutomatonFromXMLParser::parseTransitionSinglePush<PushdownStoreSymbolType>(input);
@@ -656,7 +656,7 @@ void RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownSto
} else if(sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition")) {
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition");
StateType from = AutomatonFromXMLParser::parseTransitionFrom<StateType>(input);
- std::variant < EpsilonType, InputSymbolType > inputSymbol = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol<EpsilonType,InputSymbolType>(input);
+ ext::variant < EpsilonType, InputSymbolType > inputSymbol = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol<EpsilonType,InputSymbolType>(input);
PushdownStoreSymbolType pop = AutomatonFromXMLParser::parseTransitionSinglePop<PushdownStoreSymbolType>(input);
StateType to = AutomatonFromXMLParser::parseTransitionTo<StateType>(input);
@@ -665,7 +665,7 @@ void RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownSto
} else {
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "localTransition");
StateType from = AutomatonFromXMLParser::parseTransitionFrom<StateType>(input);
- std::variant < EpsilonType, InputSymbolType > inputSymbol = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol<EpsilonType,InputSymbolType>(input);
+ ext::variant < EpsilonType, InputSymbolType > inputSymbol = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol<EpsilonType,InputSymbolType>(input);
StateType to = AutomatonFromXMLParser::parseTransitionTo<StateType>(input);
automaton.addLocalTransition(std::move(from), std::move(inputSymbol), std::move(to));
@@ -736,15 +736,15 @@ template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolTy
class ComponentConstraint< automaton::RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, automaton::InputAlphabet > {
public:
static bool used ( const automaton::RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & automaton, const InputSymbolType & symbol ) {
- for (const std::pair<const std::pair<StateType, std::variant < EpsilonType, InputSymbolType >>, std::pair<StateType, PushdownStoreSymbolType> >& callTransition : automaton.getCallTransitions())
+ for (const std::pair<const std::pair<StateType, ext::variant < EpsilonType, InputSymbolType >>, std::pair<StateType, PushdownStoreSymbolType> >& callTransition : automaton.getCallTransitions())
if (callTransition.first.second.template is < InputSymbolType >() && symbol == callTransition.first.second.template get < InputSymbolType >())
return true;
- for (const std::pair<const std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, StateType>& returnTransition : automaton.getReturnTransitions())
+ for (const std::pair<const std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, StateType>& returnTransition : automaton.getReturnTransitions())
if (std::get<1>(returnTransition.first).template is < InputSymbolType >() && symbol == std::get<1>(returnTransition.first).template get < InputSymbolType >())
return true;
- for (const std::pair<const std::pair<StateType, std::variant < EpsilonType, InputSymbolType >>, StateType>& localTransition : automaton.getLocalTransitions())
+ for (const std::pair<const std::pair<StateType, ext::variant < EpsilonType, InputSymbolType >>, StateType>& localTransition : automaton.getLocalTransitions())
if (localTransition.first.second.template is < InputSymbolType >() && symbol == localTransition.first.second.template get < InputSymbolType >())
return true;
@@ -763,11 +763,11 @@ template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolTy
class ComponentConstraint< automaton::RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, PushdownStoreSymbolType, automaton::PushdownStoreAlphabet > {
public:
static bool used ( const automaton::RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & automaton, const PushdownStoreSymbolType & symbol ) {
- for (const std::pair<const std::pair<StateType, std::variant < EpsilonType, InputSymbolType >>, std::pair<StateType, PushdownStoreSymbolType> >& callTransition : automaton.getCallTransitions())
+ for (const std::pair<const std::pair<StateType, ext::variant < EpsilonType, InputSymbolType >>, std::pair<StateType, PushdownStoreSymbolType> >& callTransition : automaton.getCallTransitions())
if (symbol == callTransition.second.second)
return true;
- for (const std::pair<const std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, StateType>& returnTransition : automaton.getReturnTransitions())
+ for (const std::pair<const std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, StateType>& returnTransition : automaton.getReturnTransitions())
if (symbol == std::get<2>(returnTransition.first))
return true;
@@ -806,15 +806,15 @@ public:
if ( automaton.getFinalStates ( ).count ( state ) )
return true;
- for (const std::pair<const std::pair<StateType, std::variant < EpsilonType, InputSymbolType >>, std::pair<StateType, PushdownStoreSymbolType> >& callTransition : automaton.getCallTransitions())
+ for (const std::pair<const std::pair<StateType, ext::variant < EpsilonType, InputSymbolType >>, std::pair<StateType, PushdownStoreSymbolType> >& callTransition : automaton.getCallTransitions())
if (state == callTransition.first.first || callTransition.second.first == state)
return true;
- for (const std::pair<const std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, StateType>& returnTransition : automaton.getReturnTransitions())
+ for (const std::pair<const std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, StateType>& returnTransition : automaton.getReturnTransitions())
if (state == std::get<0>(returnTransition.first) || returnTransition.second == state)
return true;
- for (const std::pair<const std::pair<StateType, std::variant < EpsilonType, InputSymbolType >>, StateType>& localTransition : automaton.getLocalTransitions())
+ for (const std::pair<const std::pair<StateType, ext::variant < EpsilonType, InputSymbolType >>, StateType>& localTransition : automaton.getLocalTransitions())
if (state == localTransition.first.first || localTransition.second == state)
return true;
diff --git a/alib2data/src/automaton/PDA/RealTimeHeightDeterministicNPDA.h b/alib2data/src/automaton/PDA/RealTimeHeightDeterministicNPDA.h
index 6ea0eb56f64c882cfddd597b6f1422b87d0152f3..bf28e24914af3ddfb6be778fcaed1598b8283901 100644
--- a/alib2data/src/automaton/PDA/RealTimeHeightDeterministicNPDA.h
+++ b/alib2data/src/automaton/PDA/RealTimeHeightDeterministicNPDA.h
@@ -42,9 +42,9 @@ class InitialStates;
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
class RealTimeHeightDeterministicNPDA final : public AutomatonBase, public alib::Components < RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, StateType, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > {
protected:
- std::map < std::pair < StateType, std::variant < EpsilonType, InputSymbolType > >, std::set < std::pair < StateType, PushdownStoreSymbolType > > > callTransitions;
- std::map < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, std::set < StateType > > returnTransitions;
- std::map < std::pair < StateType, std::variant < EpsilonType, InputSymbolType > >, std::set < StateType > > localTransitions;
+ std::map < std::pair < StateType, ext::variant < EpsilonType, InputSymbolType > >, std::set < std::pair < StateType, PushdownStoreSymbolType > > > callTransitions;
+ std::map < std::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, std::set < StateType > > returnTransitions;
+ std::map < std::pair < StateType, ext::variant < EpsilonType, InputSymbolType > >, std::set < StateType > > localTransitions;
public:
explicit RealTimeHeightDeterministicNPDA ( std::set < StateType > states, std::set < InputSymbolType > inputAlphabet, std::set < PushdownStoreSymbolType > pushdownStoreSymbol, std::set < StateType > initialStates, PushdownStoreSymbolType bottomOfTheStackSymbol, std::set < StateType > finalStates );
@@ -157,7 +157,7 @@ public:
* @param next next state
* @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
*/
- bool addCallTransition ( StateType current, std::variant < EpsilonType, InputSymbolType > input, StateType next, PushdownStoreSymbolType push );
+ bool addCallTransition ( StateType current, ext::variant < EpsilonType, InputSymbolType > input, StateType next, PushdownStoreSymbolType push );
bool addCallTransition ( StateType current, StateType next, PushdownStoreSymbolType push );
bool addCallTransition ( StateType current, InputSymbolType input, StateType next, PushdownStoreSymbolType push );
@@ -168,7 +168,7 @@ public:
* @param next next state
* @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
*/
- bool addReturnTransition ( StateType current, std::variant < EpsilonType, InputSymbolType > input, PushdownStoreSymbolType pop, StateType next );
+ bool addReturnTransition ( StateType current, ext::variant < EpsilonType, InputSymbolType > input, PushdownStoreSymbolType pop, StateType next );
bool addReturnTransition ( StateType current, PushdownStoreSymbolType pop, StateType next );
bool addReturnTransition ( StateType current, InputSymbolType input, PushdownStoreSymbolType pop, StateType next );
@@ -179,7 +179,7 @@ public:
* @param next next state
* @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
*/
- bool addLocalTransition ( StateType current, std::variant < EpsilonType, InputSymbolType > input, StateType next );
+ bool addLocalTransition ( StateType current, ext::variant < EpsilonType, InputSymbolType > input, StateType next );
bool addLocalTransition ( StateType current, StateType next );
bool addLocalTransition ( StateType current, InputSymbolType input, StateType next );
@@ -190,7 +190,7 @@ public:
* @param next next state
* @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
*/
- void addCallTransitions ( StateType current, std::variant < EpsilonType, InputSymbolType > input, std::set < std::pair < StateType, PushdownStoreSymbolType > > targets );
+ void addCallTransitions ( StateType current, ext::variant < EpsilonType, InputSymbolType > input, std::set < std::pair < StateType, PushdownStoreSymbolType > > targets );
void addCallTransitions ( StateType current, std::set < std::pair < StateType, PushdownStoreSymbolType > > targets );
void addCallTransitions ( StateType current, InputSymbolType input, std::set < std::pair < StateType, PushdownStoreSymbolType > > targets );
@@ -201,7 +201,7 @@ public:
* @param next next state
* @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
*/
- void addReturnTransitions ( StateType current, std::variant < EpsilonType, InputSymbolType > input, PushdownStoreSymbolType pop, std::set < StateType > next );
+ void addReturnTransitions ( StateType current, ext::variant < EpsilonType, InputSymbolType > input, PushdownStoreSymbolType pop, std::set < StateType > next );
void addReturnTransitions ( StateType current, PushdownStoreSymbolType pop, std::set < StateType > next );
void addReturnTransitions ( StateType current, InputSymbolType input, PushdownStoreSymbolType pop, std::set < StateType > next );
@@ -212,7 +212,7 @@ public:
* @param next next state
* @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
*/
- void addLocalTransitions ( StateType current, std::variant < EpsilonType, InputSymbolType > input, std::set < StateType > next );
+ void addLocalTransitions ( StateType current, ext::variant < EpsilonType, InputSymbolType > input, std::set < StateType > next );
void addLocalTransitions ( StateType current, std::set < StateType > next );
void addLocalTransitions ( StateType current, InputSymbolType input, std::set < StateType > next );
@@ -221,7 +221,7 @@ public:
* @param transition transition to remove
* @throws AutomatonException when transition doesn't exists.
*/
- bool removeCallTransition ( const StateType & current, const std::variant < EpsilonType, InputSymbolType > & input, const StateType & next, const PushdownStoreSymbolType & push );
+ bool removeCallTransition ( const StateType & current, const ext::variant < EpsilonType, InputSymbolType > & input, const StateType & next, const PushdownStoreSymbolType & push );
bool removeCallTransition ( const StateType & current, const StateType & next, const PushdownStoreSymbolType & push );
bool removeCallTransition ( const StateType & current, const InputSymbolType & input, const StateType & next, const PushdownStoreSymbolType & push );
@@ -230,7 +230,7 @@ public:
* @param transition transition to remove
* @throws AutomatonException when transition doesn't exists.
*/
- bool removeReturnTransition ( const StateType & current, const std::variant < EpsilonType, InputSymbolType > & input, const PushdownStoreSymbolType & pop, const StateType & next );
+ bool removeReturnTransition ( const StateType & current, const ext::variant < EpsilonType, InputSymbolType > & input, const PushdownStoreSymbolType & pop, const StateType & next );
bool removeReturnTransition ( const StateType & current, const PushdownStoreSymbolType & pop, const StateType & next );
bool removeReturnTransition ( const StateType & current, const InputSymbolType & input, const PushdownStoreSymbolType & pop, const StateType & next );
@@ -239,15 +239,15 @@ public:
* @param transition transition to remove
* @throws AutomatonException when transition doesn't exists.
*/
- bool removeLocalTransition ( const StateType & current, const std::variant < EpsilonType, InputSymbolType > & input, const StateType & next );
+ bool removeLocalTransition ( const StateType & current, const ext::variant < EpsilonType, InputSymbolType > & input, const StateType & next );
bool removeLocalTransition ( const StateType & current, const StateType & next );
bool removeLocalTransition ( const StateType & current, const InputSymbolType & input, const StateType & next );
- const std::map < std::pair < StateType, std::variant < EpsilonType, InputSymbolType > >, std::set < std::pair < StateType, PushdownStoreSymbolType > > > & getCallTransitions ( ) const;
+ const std::map < std::pair < StateType, ext::variant < EpsilonType, InputSymbolType > >, std::set < std::pair < StateType, PushdownStoreSymbolType > > > & getCallTransitions ( ) const;
- const std::map < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, std::set < StateType > > & getReturnTransitions ( ) const;
+ const std::map < std::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, std::set < StateType > > & getReturnTransitions ( ) const;
- const std::map < std::pair < StateType, std::variant < EpsilonType, InputSymbolType > >, std::set < StateType > > & getLocalTransitions ( ) const;
+ const std::map < std::pair < StateType, ext::variant < EpsilonType, InputSymbolType > >, std::set < StateType > > & getLocalTransitions ( ) const;
virtual int compare ( const ObjectBase & other ) const {
if ( std::type_index ( typeid ( * this ) ) == std::type_index ( typeid ( other ) ) ) return this->compare ( ( decltype ( * this ) )other );
@@ -290,31 +290,31 @@ public:
RealTimeHeightDeterministicNPDA < > * res = new RealTimeHeightDeterministicNPDA < > ( std::move ( states ), std::move ( alphabet ), std::move ( pushdownAlphabet ), std::move ( initialStates ), std::move ( bottomSymbol ), std::move ( finalStates ) );
- for ( std::pair < std::pair < StateType, std::variant < EpsilonType, InputSymbolType > >, std::set < std::pair < StateType, PushdownStoreSymbolType > > > && transition : std::make_moveable_map ( callTransitions ) ) {
+ for ( std::pair < std::pair < StateType, ext::variant < EpsilonType, InputSymbolType > >, std::set < std::pair < StateType, PushdownStoreSymbolType > > > && transition : std::make_moveable_map ( callTransitions ) ) {
std::set < std::pair < DefaultStateType, DefaultSymbolType > > targets;
for ( std::pair < StateType, PushdownStoreSymbolType > && target : std::make_moveable_set ( transition.second ) )
targets.insert ( std::make_pair ( AutomatonNormalize::normalizeState ( std::move ( target.first ) ), alphabet::SymbolNormalize::normalizeSymbol ( std::move ( target.second ) ) ) );
DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) );
- std::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( transition.first.second ) );
+ ext::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( transition.first.second ) );
res->addCallTransitions ( std::move ( from ), std::move ( input ), std::move ( targets ) );
}
- for ( std::pair < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, std::set < StateType > > && transition : std::make_moveable_map ( returnTransitions ) ) {
+ for ( std::pair < std::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, std::set < StateType > > && transition : std::make_moveable_map ( returnTransitions ) ) {
std::set < DefaultStateType > targets = AutomatonNormalize::normalizeStates ( std::move ( transition.second ) );
DefaultSymbolType pop = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( std::get < 2 > ( transition.first ) ) );
DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( std::get < 0 > ( transition.first ) ) );
- std::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( std::get < 1 > ( transition.first ) ) );
+ ext::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( std::get < 1 > ( transition.first ) ) );
res->addReturnTransitions ( std::move ( from ), std::move ( input ), std::move ( pop ), std::move ( targets ) );
}
- for ( std::pair < std::pair < StateType, std::variant < EpsilonType, InputSymbolType > >, std::set < StateType > > && transition : std::make_moveable_map ( localTransitions ) ) {
+ for ( std::pair < std::pair < StateType, ext::variant < EpsilonType, InputSymbolType > >, std::set < StateType > > && transition : std::make_moveable_map ( localTransitions ) ) {
std::set < DefaultStateType > targets = AutomatonNormalize::normalizeStates ( std::move ( transition.second ) );
DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) );
- std::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( transition.first.second ) );
+ ext::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( transition.first.second ) );
res->addLocalTransitions ( std::move ( from ), std::move ( input ), std::move ( targets ) );
}
@@ -342,7 +342,7 @@ AutomatonBase* RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, P
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-bool RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addCallTransition(StateType from, std::variant < EpsilonType, InputSymbolType > input, StateType to, PushdownStoreSymbolType push) {
+bool RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addCallTransition(StateType from, ext::variant < EpsilonType, InputSymbolType > input, StateType to, PushdownStoreSymbolType push) {
if (! getStates().count(from)) {
throw AutomatonException("State \"" + ext::to_string ( from ) + "\" doesn't exist.");
}
@@ -359,7 +359,7 @@ bool RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownSto
throw AutomatonException("Pushdown store symbol \"" + ext::to_string ( push ) + "\" doesn't exist.");
}
- std::pair<StateType, std::variant < EpsilonType, InputSymbolType >> key(std::move(from), std::move(input));
+ std::pair<StateType, ext::variant < EpsilonType, InputSymbolType >> key(std::move(from), std::move(input));
std::pair<StateType, PushdownStoreSymbolType> value = std::make_pair(std::move(to), std::move(push));
return callTransitions[std::move(key)].insert(std::move(value)).second;
@@ -367,18 +367,18 @@ bool RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownSto
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addCallTransition(StateType from, StateType to, PushdownStoreSymbolType push) {
- auto inputVariant = std::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
+ auto inputVariant = ext::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
return addCallTransition(std::move(from), std::move(inputVariant), std::move(to), std::move(push));
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addCallTransition(StateType from, InputSymbolType input, StateType to, PushdownStoreSymbolType push) {
- std::variant < EpsilonType, InputSymbolType > inputVariant(input);
+ ext::variant < EpsilonType, InputSymbolType > inputVariant(input);
return addCallTransition(std::move(from), std::move(inputVariant), std::move(to), std::move(push));
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-bool RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addReturnTransition(StateType from, std::variant < EpsilonType, InputSymbolType > input, PushdownStoreSymbolType pop, StateType to) {
+bool RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addReturnTransition(StateType from, ext::variant < EpsilonType, InputSymbolType > input, PushdownStoreSymbolType pop, StateType to) {
if (! getStates().count(from)) {
throw AutomatonException("State \"" + ext::to_string ( from ) + "\" doesn't exist.");
}
@@ -395,25 +395,25 @@ bool RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownSto
throw AutomatonException("Pushdown store symbol \"" + ext::to_string ( pop ) + "\" doesn't exist.");
}
- std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType> key(std::move(from), std::move(input), std::move(pop));
+ std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType> key(std::move(from), std::move(input), std::move(pop));
return returnTransitions[std::move(key)].insert(std::move(to)).second;
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addReturnTransition(StateType from, PushdownStoreSymbolType pop, StateType to) {
- auto inputVariant = std::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
+ auto inputVariant = ext::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
return addReturnTransition(std::move(from), std::move(inputVariant), std::move(pop), std::move(to));
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addReturnTransition(StateType from, InputSymbolType input, PushdownStoreSymbolType pop, StateType to) {
- std::variant < EpsilonType, InputSymbolType > inputVariant(std::move(input));
+ ext::variant < EpsilonType, InputSymbolType > inputVariant(std::move(input));
return addReturnTransition(std::move(from), std::move(inputVariant), std::move(pop), std::move(to));
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-bool RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addLocalTransition(StateType from, std::variant < EpsilonType, InputSymbolType > input, StateType to) {
+bool RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addLocalTransition(StateType from, ext::variant < EpsilonType, InputSymbolType > input, StateType to) {
if (! getStates().count(from)) {
throw AutomatonException("State \"" + ext::to_string ( from ) + "\" doesn't exist.");
}
@@ -426,25 +426,25 @@ bool RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownSto
throw AutomatonException("State \"" + ext::to_string ( to ) + "\" doesn't exist.");
}
- std::pair<StateType, std::variant < EpsilonType, InputSymbolType >> key(std::move(from), std::move(input));
+ std::pair<StateType, ext::variant < EpsilonType, InputSymbolType >> key(std::move(from), std::move(input));
return localTransitions[std::move(key)].insert(std::move(to)).second;
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addLocalTransition(StateType from, StateType to) {
- auto inputVariant = std::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
+ auto inputVariant = ext::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
return addLocalTransition(std::move(from), std::move(inputVariant), std::move(to));
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addLocalTransition(StateType from, InputSymbolType input, StateType to) {
- std::variant < EpsilonType, InputSymbolType > inputVariant(std::move(input));
+ ext::variant < EpsilonType, InputSymbolType > inputVariant(std::move(input));
return addLocalTransition(std::move(from), std::move(inputVariant), std::move(to));
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-void RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addCallTransitions(StateType from, std::variant < EpsilonType, InputSymbolType > input, std::set < std::pair < StateType, PushdownStoreSymbolType > > targets ) {
+void RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addCallTransitions(StateType from, ext::variant < EpsilonType, InputSymbolType > input, std::set < std::pair < StateType, PushdownStoreSymbolType > > targets ) {
if (! getStates().count(from))
throw AutomatonException("State \"" + ext::to_string ( from ) + "\" doesn't exist.");
@@ -459,24 +459,24 @@ void RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownSto
throw AutomatonException("Pushdown store symbol \"" + ext::to_string ( target.second ) + "\" doesn't exist.");
}
- std::pair < StateType, std::variant < EpsilonType, InputSymbolType > > key ( std::move ( from ), std::move ( input ) );
+ std::pair < StateType, ext::variant < EpsilonType, InputSymbolType > > key ( std::move ( from ), std::move ( input ) );
callTransitions [ std::move ( key ) ].insert ( std::make_moveable_set ( targets ).begin ( ), std::make_moveable_set ( targets ).end ( ) );
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
void RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addCallTransitions(StateType from, std::set < std::pair < StateType, PushdownStoreSymbolType > > targets ) {
- auto inputVariant = std::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
+ auto inputVariant = ext::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
addCallTransitions(std::move(from), std::move(inputVariant), std::move ( targets ) );
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
void RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addCallTransitions(StateType from, InputSymbolType input, std::set < std::pair < StateType, PushdownStoreSymbolType > > targets ) {
- std::variant < EpsilonType, InputSymbolType > inputVariant(input);
+ ext::variant < EpsilonType, InputSymbolType > inputVariant(input);
addCallTransitions(std::move(from), std::move(inputVariant), std::move ( targets ) );
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-void RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addReturnTransitions(StateType from, std::variant < EpsilonType, InputSymbolType > input, PushdownStoreSymbolType pop, std::set < StateType > to) {
+void RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addReturnTransitions(StateType from, ext::variant < EpsilonType, InputSymbolType > input, PushdownStoreSymbolType pop, std::set < StateType > to) {
if (! getStates().count(from))
throw AutomatonException("State \"" + ext::to_string ( from ) + "\" doesn't exist.");
@@ -489,24 +489,24 @@ void RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownSto
if ( ! getPushdownStoreAlphabet().count ( pop ) )
throw AutomatonException("Pushdown store symbol \"" + ext::to_string ( pop ) + "\" doesn't exist.");
- std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType> key(std::move(from), std::move(input), std::move(pop));
+ std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType> key(std::move(from), std::move(input), std::move(pop));
returnTransitions[std::move(key)].insert ( std::make_moveable_set ( to ).begin ( ), std::make_moveable_set ( to ).end ( ) );
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
void RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addReturnTransitions(StateType from, PushdownStoreSymbolType pop, std::set < StateType > to) {
- auto inputVariant = std::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
+ auto inputVariant = ext::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
addReturnTransitions(std::move(from), std::move(inputVariant), std::move(pop), std::move(to));
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
void RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addReturnTransitions(StateType from, InputSymbolType input, PushdownStoreSymbolType pop, std::set < StateType > to) {
- std::variant < EpsilonType, InputSymbolType > inputVariant(std::move(input));
+ ext::variant < EpsilonType, InputSymbolType > inputVariant(std::move(input));
addReturnTransitions(std::move(from), std::move(inputVariant), std::move(pop), std::move(to));
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-void RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addLocalTransitions(StateType from, std::variant < EpsilonType, InputSymbolType > input, std::set < StateType > to) {
+void RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addLocalTransitions(StateType from, ext::variant < EpsilonType, InputSymbolType > input, std::set < StateType > to) {
if (! getStates().count(from))
throw AutomatonException("State \"" + ext::to_string ( from ) + "\" doesn't exist.");
@@ -516,25 +516,25 @@ void RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownSto
if ( !std::includes ( getStates ( ).begin ( ), getStates ( ).end ( ), to.begin ( ), to.end ( ) ) )
throw AutomatonException ( "Some target states don't exist." );
- std::pair<StateType, std::variant < EpsilonType, InputSymbolType >> key(std::move(from), std::move(input));
+ std::pair<StateType, ext::variant < EpsilonType, InputSymbolType >> key(std::move(from), std::move(input));
localTransitions[std::move(key)].insert ( std::make_moveable_set ( to ).begin ( ), std::make_moveable_set ( to ).end ( ) );
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
void RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addLocalTransitions(StateType from, std::set < StateType > to) {
- auto inputVariant = std::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
+ auto inputVariant = ext::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
addLocalTransitions(std::move(from), std::move(inputVariant), std::move(to));
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
void RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addLocalTransitions(StateType from, InputSymbolType input, std::set < StateType > to) {
- std::variant < EpsilonType, InputSymbolType > inputVariant(std::move(input));
+ ext::variant < EpsilonType, InputSymbolType > inputVariant(std::move(input));
addLocalTransitions(std::move(from), std::move(inputVariant), std::move(to));
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-bool RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeCallTransition(const StateType& from, const std::variant < EpsilonType, InputSymbolType >& input, const StateType& to, const PushdownStoreSymbolType& push) {
- std::pair<StateType, std::variant < EpsilonType, InputSymbolType >> key(from, input);
+bool RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeCallTransition(const StateType& from, const ext::variant < EpsilonType, InputSymbolType >& input, const StateType& to, const PushdownStoreSymbolType& push) {
+ std::pair<StateType, ext::variant < EpsilonType, InputSymbolType >> key(from, input);
std::pair<StateType, PushdownStoreSymbolType> value = std::make_pair(to, push);
return callTransitions[key].erase(value);
@@ -542,66 +542,66 @@ bool RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownSto
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeCallTransition(const StateType& from, const StateType& to, const PushdownStoreSymbolType& push) {
- auto inputVariant = std::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
+ auto inputVariant = ext::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
return removeCallTransition(from, inputVariant, to, push);
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeCallTransition(const StateType& from, const InputSymbolType& input, const StateType& to, const PushdownStoreSymbolType& push) {
- std::variant < EpsilonType, InputSymbolType > inputVariant(input);
+ ext::variant < EpsilonType, InputSymbolType > inputVariant(input);
return removeCallTransition(from, inputVariant, to, push);
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-bool RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeReturnTransition(const StateType& from, const std::variant < EpsilonType, InputSymbolType >& input, const PushdownStoreSymbolType& pop, const StateType& to) {
- std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType> key(from, input, pop);
+bool RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeReturnTransition(const StateType& from, const ext::variant < EpsilonType, InputSymbolType >& input, const PushdownStoreSymbolType& pop, const StateType& to) {
+ std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType> key(from, input, pop);
return returnTransitions[key].erase(to);
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeReturnTransition(const StateType& from, const PushdownStoreSymbolType& pop, const StateType& to) {
- auto inputVariant = std::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
+ auto inputVariant = ext::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
return removeReturnTransition(from, inputVariant, pop, to);
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeReturnTransition(const StateType& from, const InputSymbolType& input, const PushdownStoreSymbolType& pop, const StateType& to) {
- std::variant < EpsilonType, InputSymbolType > inputVariant(input);
+ ext::variant < EpsilonType, InputSymbolType > inputVariant(input);
return removeReturnTransition(from, inputVariant, pop, to);
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-bool RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeLocalTransition(const StateType& from, const std::variant < EpsilonType, InputSymbolType >& input, const StateType& to) {
- std::pair<StateType, std::variant < EpsilonType, InputSymbolType >> key(from, input);
+bool RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeLocalTransition(const StateType& from, const ext::variant < EpsilonType, InputSymbolType >& input, const StateType& to) {
+ std::pair<StateType, ext::variant < EpsilonType, InputSymbolType >> key(from, input);
return localTransitions[key].erase(to);
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeLocalTransition(const StateType& from, const StateType& to) {
- auto inputVariant = std::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
+ auto inputVariant = ext::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
return removeLocalTransition(from, inputVariant, to);
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeLocalTransition(const StateType& from, const InputSymbolType& input, const StateType& to) {
- std::variant < EpsilonType, InputSymbolType > inputVariant(input);
+ ext::variant < EpsilonType, InputSymbolType > inputVariant(input);
return removeLocalTransition(from, inputVariant, to);
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-const std::map<std::pair<StateType, std::variant < EpsilonType, InputSymbolType >>, std::set<std::pair<StateType, PushdownStoreSymbolType> > >& RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getCallTransitions() const {
+const std::map<std::pair<StateType, ext::variant < EpsilonType, InputSymbolType >>, std::set<std::pair<StateType, PushdownStoreSymbolType> > >& RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getCallTransitions() const {
return callTransitions;
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-const std::map<std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, std::set<StateType> >& RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getReturnTransitions() const {
+const std::map<std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, std::set<StateType> >& RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getReturnTransitions() const {
return returnTransitions;
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-const std::map<std::pair<StateType, std::variant < EpsilonType, InputSymbolType >>, std::set<StateType> >& RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getLocalTransitions() const {
+const std::map<std::pair<StateType, ext::variant < EpsilonType, InputSymbolType >>, std::set<StateType> >& RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getLocalTransitions() const {
return localTransitions;
}
@@ -665,7 +665,7 @@ void RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownSto
if(sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, "callTransition")) {
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "callTransition");
StateType from = AutomatonFromXMLParser::parseTransitionFrom<StateType>(input);
- std::variant < EpsilonType, InputSymbolType > inputSymbol = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol<EpsilonType, InputSymbolType>(input);
+ ext::variant < EpsilonType, InputSymbolType > inputSymbol = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol<EpsilonType, InputSymbolType>(input);
StateType to = AutomatonFromXMLParser::parseTransitionTo<StateType>(input);
PushdownStoreSymbolType push = AutomatonFromXMLParser::parseTransitionSinglePush<PushdownStoreSymbolType>(input);
@@ -674,7 +674,7 @@ void RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownSto
} else if(sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition")) {
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition");
StateType from = AutomatonFromXMLParser::parseTransitionFrom<StateType>(input);
- std::variant < EpsilonType, InputSymbolType > inputSymbol = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol<EpsilonType, InputSymbolType>(input);
+ ext::variant < EpsilonType, InputSymbolType > inputSymbol = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol<EpsilonType, InputSymbolType>(input);
PushdownStoreSymbolType pop = AutomatonFromXMLParser::parseTransitionSinglePop<PushdownStoreSymbolType>(input);
StateType to = AutomatonFromXMLParser::parseTransitionTo<StateType>(input);
@@ -683,7 +683,7 @@ void RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownSto
} else {
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "localTransition");
StateType from = AutomatonFromXMLParser::parseTransitionFrom<StateType>(input);
- std::variant < EpsilonType, InputSymbolType > inputSymbol = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol<EpsilonType, InputSymbolType>(input);
+ ext::variant < EpsilonType, InputSymbolType > inputSymbol = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol<EpsilonType, InputSymbolType>(input);
StateType to = AutomatonFromXMLParser::parseTransitionTo<StateType>(input);
automaton.addLocalTransition(std::move(from), std::move(inputSymbol), std::move(to));
@@ -760,15 +760,15 @@ template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolTy
class ComponentConstraint< automaton::RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, automaton::InputAlphabet > {
public:
static bool used ( const automaton::RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & automaton, const InputSymbolType & symbol ) {
- for (const std::pair<const std::pair<StateType, std::variant < EpsilonType, InputSymbolType >>, std::set<std::pair<StateType, PushdownStoreSymbolType> > >& callTransition : automaton.getCallTransitions())
+ for (const std::pair<const std::pair<StateType, ext::variant < EpsilonType, InputSymbolType >>, std::set<std::pair<StateType, PushdownStoreSymbolType> > >& callTransition : automaton.getCallTransitions())
if (callTransition.first.second.template is < InputSymbolType >() && symbol == callTransition.first.second.template get < InputSymbolType >())
return true;
- for (const std::pair<const std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, std::set<StateType> >& returnTransition : automaton.getReturnTransitions())
+ for (const std::pair<const std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, std::set<StateType> >& returnTransition : automaton.getReturnTransitions())
if (std::get<1>(returnTransition.first).template is < InputSymbolType >() && symbol == std::get<1>(returnTransition.first).template get < InputSymbolType >())
return true;
- for (const std::pair<const std::pair<StateType, std::variant < EpsilonType, InputSymbolType >>, std::set<StateType> >& localTransition : automaton.getLocalTransitions())
+ for (const std::pair<const std::pair<StateType, ext::variant < EpsilonType, InputSymbolType >>, std::set<StateType> >& localTransition : automaton.getLocalTransitions())
if (localTransition.first.second.template is < InputSymbolType >() && symbol == localTransition.first.second.template get < InputSymbolType >())
return true;
@@ -790,12 +790,12 @@ public:
if(automaton.getBottomOfTheStackSymbol() == symbol)
return true;
- for (const std::pair<const std::pair<StateType, std::variant < EpsilonType, InputSymbolType >>, std::set<std::pair<StateType, PushdownStoreSymbolType> > >& callTransition : automaton.getCallTransitions())
+ for (const std::pair<const std::pair<StateType, ext::variant < EpsilonType, InputSymbolType >>, std::set<std::pair<StateType, PushdownStoreSymbolType> > >& callTransition : automaton.getCallTransitions())
for(const std::pair<StateType, PushdownStoreSymbolType>& to : callTransition.second)
if (symbol == to.second)
return true;
- for (const std::pair<const std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, std::set<StateType> >& returnTransition : automaton.getReturnTransitions())
+ for (const std::pair<const std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, std::set<StateType> >& returnTransition : automaton.getReturnTransitions())
if (symbol == std::get<2>(returnTransition.first))
return true;
@@ -831,7 +831,7 @@ public:
if ( automaton.getFinalStates ( ).count ( state ) )
return true;
- for (const std::pair<const std::pair<StateType, std::variant < EpsilonType, InputSymbolType >>, std::set<std::pair<StateType, PushdownStoreSymbolType> > >& callTransition : automaton.getCallTransitions()) {
+ for (const std::pair<const std::pair<StateType, ext::variant < EpsilonType, InputSymbolType >>, std::set<std::pair<StateType, PushdownStoreSymbolType> > >& callTransition : automaton.getCallTransitions()) {
if (state == callTransition.first.first)
return true;
@@ -840,7 +840,7 @@ public:
return true;
}
- for (const std::pair<const std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, std::set<StateType> >& returnTransition : automaton.getReturnTransitions()) {
+ for (const std::pair<const std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, std::set<StateType> >& returnTransition : automaton.getReturnTransitions()) {
if (state == std::get<0>(returnTransition.first))
return true;
@@ -849,7 +849,7 @@ public:
return true;
}
- for (const std::pair<const std::pair<StateType, std::variant < EpsilonType, InputSymbolType >>, std::set<StateType> >& localTransition : automaton.getLocalTransitions()) {
+ for (const std::pair<const std::pair<StateType, ext::variant < EpsilonType, InputSymbolType >>, std::set<StateType> >& localTransition : automaton.getLocalTransitions()) {
if (state == localTransition.first.first)
return true;
diff --git a/alib2data/src/automaton/PDA/SinglePopDPDA.h b/alib2data/src/automaton/PDA/SinglePopDPDA.h
index 395d7c448a646cd39217bc4b4bdfddfec9e47e84..cd654d4e2aa96d7fb272758d1d3a733de07b6094 100644
--- a/alib2data/src/automaton/PDA/SinglePopDPDA.h
+++ b/alib2data/src/automaton/PDA/SinglePopDPDA.h
@@ -47,7 +47,7 @@ class InitialState;
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
class SinglePopDPDA final : public AutomatonBase, public alib::Components < SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < InitialSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
protected:
- std::map < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, std::pair < StateType, std::vector < PushdownStoreSymbolType > > > transitions;
+ std::map < std::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, std::pair < StateType, std::vector < PushdownStoreSymbolType > > > transitions;
public:
explicit SinglePopDPDA ( std::set < StateType > states, std::set < InputSymbolType > inputAlphabet, std::set < PushdownStoreSymbolType > pushdownStoreSymbol, StateType initialState, PushdownStoreSymbolType initialPushdownSymbol, std::set < StateType > finalStates );
@@ -151,7 +151,7 @@ public:
* @throws AutomatonException when some part of the transition is not present
* in the SinglePopDPDA (state, input symbol, stack symbol) or when transition already exists
*/
- bool addTransition ( StateType from, std::variant < EpsilonType, InputSymbolType > input, PushdownStoreSymbolType pop, StateType to, std::vector < PushdownStoreSymbolType > push );
+ bool addTransition ( StateType from, ext::variant < EpsilonType, InputSymbolType > input, PushdownStoreSymbolType pop, StateType to, std::vector < PushdownStoreSymbolType > push );
bool addTransition ( StateType from, InputSymbolType input, PushdownStoreSymbolType pop, StateType to, std::vector < PushdownStoreSymbolType > push );
@@ -162,7 +162,7 @@ public:
* @param transition transition to remove
* @throws AutomatonException when transition is not present in the SinglePopDPDA
*/
- bool removeTransition ( const StateType & from, const std::variant < EpsilonType, InputSymbolType > & input, const PushdownStoreSymbolType & pop, const StateType & to, const std::vector < PushdownStoreSymbolType > & push );
+ bool removeTransition ( const StateType & from, const ext::variant < EpsilonType, InputSymbolType > & input, const PushdownStoreSymbolType & pop, const StateType & to, const std::vector < PushdownStoreSymbolType > & push );
bool removeTransition ( const StateType & from, const InputSymbolType & input, const PushdownStoreSymbolType & pop, const StateType & to, const std::vector < PushdownStoreSymbolType > & push );
@@ -171,7 +171,7 @@ public:
/**
* @return SinglePopDPDA transitions
*/
- const std::map < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, std::pair < StateType, std::vector < PushdownStoreSymbolType > > > & getTransitions ( ) const;
+ const std::map < std::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, std::pair < StateType, std::vector < PushdownStoreSymbolType > > > & getTransitions ( ) const;
virtual int compare ( const ObjectBase & other ) const {
if ( std::type_index ( typeid ( * this ) ) == std::type_index ( typeid ( other ) ) ) return this->compare ( ( decltype ( * this ) )other );
@@ -214,13 +214,13 @@ public:
SinglePopDPDA < > * res = new SinglePopDPDA < > ( std::move ( states ), std::move ( alphabet ), std::move ( pushdownAlphabet ), std::move ( initialState ), std::move ( bottomSymbol ), std::move ( finalStates ) );
- for ( std::pair < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, std::pair < StateType, std::vector < PushdownStoreSymbolType > > > && transition : std::make_moveable_map ( transitions ) ) {
+ for ( std::pair < std::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, std::pair < StateType, std::vector < PushdownStoreSymbolType > > > && transition : std::make_moveable_map ( transitions ) ) {
DefaultStateType to = AutomatonNormalize::normalizeState ( std::move ( transition.second.first ) );
std::vector < DefaultSymbolType > push = alphabet::SymbolNormalize::normalizeSymbols ( std::move ( transition.second.second ) );
DefaultSymbolType pop = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( std::get < 2 > ( transition.first ) ) );
DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( std::get < 0 > ( transition.first ) ) );
- std::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( std::get < 1 > ( transition.first ) ) );
+ ext::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( std::get < 1 > ( transition.first ) ) );
res->addTransition ( std::move ( from ), std::move ( input ), std::move ( pop ), std::move ( to ), std::move ( push ) );
}
@@ -248,7 +248,7 @@ AutomatonBase* SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbol
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-bool SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransition(StateType from, std::variant < EpsilonType, InputSymbolType > input, PushdownStoreSymbolType pop, StateType to, std::vector<PushdownStoreSymbolType> push) {
+bool SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransition(StateType from, ext::variant < EpsilonType, InputSymbolType > input, PushdownStoreSymbolType pop, StateType to, std::vector<PushdownStoreSymbolType> push) {
if (!getStates().count(from)) {
throw AutomatonException("State \"" + ext::to_string ( from ) + "\" doesn't exist.");
}
@@ -271,7 +271,7 @@ bool SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, Stat
}
}
- std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType> key(std::move(from), std::move(input), std::move(pop));
+ std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType> key(std::move(from), std::move(input), std::move(pop));
std::pair<StateType, std::vector<PushdownStoreSymbolType> > value = std::make_pair(std::move(to), std::move(push));
if (transitions.find(key) != transitions.end()) {
@@ -284,13 +284,13 @@ bool SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, Stat
}
if(input.template is<EpsilonType>()) {
- if(std::any_of(transitions.begin(), transitions.end(), [&](const std::pair<std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, std::pair<StateType, std::vector<PushdownStoreSymbolType> > > & transition) {
+ if(std::any_of(transitions.begin(), transitions.end(), [&](const std::pair<std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, std::pair<StateType, std::vector<PushdownStoreSymbolType> > > & transition) {
if(std::get<0>(transition.first) == std::get<0>(key) && std::get<2>(transition.first) == std::get<2>(key)) return true;
return false;
}))
throw AutomatonException("Conflicting transition");
} else {
- std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType> key2(std::get<0>(key), std::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( ), std::get<2>(key));
+ std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType> key2(std::get<0>(key), ext::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( ), std::get<2>(key));
if(transitions.find(key2) != transitions.end())
throw AutomatonException("Conflicting transition");
}
@@ -301,19 +301,19 @@ bool SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, Stat
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransition(StateType from, InputSymbolType input, PushdownStoreSymbolType pop, StateType to, std::vector<PushdownStoreSymbolType> push) {
- std::variant < EpsilonType, InputSymbolType > inputVariant(std::move(input));
+ ext::variant < EpsilonType, InputSymbolType > inputVariant(std::move(input));
return addTransition(std::move(from), std::move(inputVariant), std::move(pop), std::move(to), std::move(push));
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransition(StateType from, PushdownStoreSymbolType pop, StateType to, std::vector<PushdownStoreSymbolType> push) {
- auto inputVariant = std::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
+ auto inputVariant = ext::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
return addTransition(std::move(from), std::move(inputVariant), std::move(pop), std::move(to), std::move(push));
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-bool SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeTransition(const StateType& from, const std::variant < EpsilonType, InputSymbolType >& input, const PushdownStoreSymbolType& pop, const StateType& to, const std::vector<PushdownStoreSymbolType>& push) {
- std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType> key(from, input, pop);
+bool SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeTransition(const StateType& from, const ext::variant < EpsilonType, InputSymbolType >& input, const PushdownStoreSymbolType& pop, const StateType& to, const std::vector<PushdownStoreSymbolType>& push) {
+ std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType> key(from, input, pop);
std::pair<StateType, std::vector<PushdownStoreSymbolType> > value = std::make_pair(to, push);
if (transitions.find(key) == transitions.end())
@@ -332,18 +332,18 @@ bool SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, Stat
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeTransition(const StateType& from, const InputSymbolType& input, const PushdownStoreSymbolType& pop, const StateType& to, const std::vector<PushdownStoreSymbolType>& push) {
- std::variant < EpsilonType, InputSymbolType > inputVariant(input);
+ ext::variant < EpsilonType, InputSymbolType > inputVariant(input);
return removeTransition(from, inputVariant, pop, to, push);
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeTransition(const StateType& from, const PushdownStoreSymbolType& pop, const StateType& to, const std::vector<PushdownStoreSymbolType>& push) {
- auto inputVariant = std::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
+ auto inputVariant = ext::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
return removeTransition(from, inputVariant, pop, to, push);
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-const std::map<std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, std::pair<StateType, std::vector<PushdownStoreSymbolType> > >& SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getTransitions() const {
+const std::map<std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, std::pair<StateType, std::vector<PushdownStoreSymbolType> > >& SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getTransitions() const {
return transitions;
}
@@ -403,7 +403,7 @@ template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolTy
void SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::parseTransition(std::deque<sax::Token>::iterator& input, SinglePopDPDA& automaton) {
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
StateType from = AutomatonFromXMLParser::parseTransitionFrom<StateType>(input);
- std::variant < EpsilonType, InputSymbolType > inputSymbol = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol<EpsilonType, InputSymbolType>(input);
+ ext::variant < EpsilonType, InputSymbolType > inputSymbol = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol<EpsilonType, InputSymbolType>(input);
PushdownStoreSymbolType pop = AutomatonFromXMLParser::parseTransitionSinglePop<PushdownStoreSymbolType>(input);
StateType to = AutomatonFromXMLParser::parseTransitionTo<StateType>(input);
std::vector<PushdownStoreSymbolType> push = AutomatonFromXMLParser::parseTransitionPush<PushdownStoreSymbolType>(input);
@@ -458,7 +458,7 @@ template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolTy
class ComponentConstraint< automaton::SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, automaton::InputAlphabet > {
public:
static bool used ( const automaton::SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & automaton, const InputSymbolType & symbol ) {
- for (const std::pair<const std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, std::pair<StateType, std::vector<PushdownStoreSymbolType> > >& transition : automaton.getTransitions())
+ for (const std::pair<const std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, std::pair<StateType, std::vector<PushdownStoreSymbolType> > >& transition : automaton.getTransitions())
if (std::get<1>(transition.first).template is < InputSymbolType >() && symbol == std::get<1>(transition.first).template get < InputSymbolType >())
return true;
@@ -477,7 +477,7 @@ template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolTy
class ComponentConstraint< automaton::SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, PushdownStoreSymbolType, automaton::PushdownStoreAlphabet > {
public:
static bool used ( const automaton::SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & automaton, const PushdownStoreSymbolType & symbol ) {
- for (const std::pair<const std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, std::pair<StateType, std::vector<PushdownStoreSymbolType> > >& transition : automaton.getTransitions())
+ for (const std::pair<const std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, std::pair<StateType, std::vector<PushdownStoreSymbolType> > >& transition : automaton.getTransitions())
if (symbol == std::get<2>(transition.first) || std::find(transition.second.second.begin(), transition.second.second.end(), symbol) != transition.second.second.end())
return true;
@@ -516,7 +516,7 @@ public:
if ( automaton.getFinalStates ( ).count ( state ) )
return true;
- for (const std::pair<const std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, std::pair<StateType, std::vector<PushdownStoreSymbolType> > >& transition : automaton.getTransitions())
+ for (const std::pair<const std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, std::pair<StateType, std::vector<PushdownStoreSymbolType> > >& transition : automaton.getTransitions())
if (state == std::get<0>(transition.first) || transition.second.first == state)
return true;
diff --git a/alib2data/src/automaton/PDA/SinglePopNPDA.h b/alib2data/src/automaton/PDA/SinglePopNPDA.h
index dd531f540658abfea8d6554a2a988960e63986d8..d740e8b7e66e96667087a6fdb2c6c511c0be2b37 100644
--- a/alib2data/src/automaton/PDA/SinglePopNPDA.h
+++ b/alib2data/src/automaton/PDA/SinglePopNPDA.h
@@ -42,7 +42,7 @@ class InitialState;
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
class SinglePopNPDA final : public AutomatonBase, public alib::Components < SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < InitialSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
protected:
- std::map < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, std::set < std::pair < StateType, std::vector < PushdownStoreSymbolType > > > > transitions;
+ std::map < std::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, std::set < std::pair < StateType, std::vector < PushdownStoreSymbolType > > > > transitions;
public:
explicit SinglePopNPDA ( std::set < StateType > states, std::set < InputSymbolType > inputAlphabet, std::set < PushdownStoreSymbolType > pushdownStoreSymbol, StateType initialState, PushdownStoreSymbolType initialPushdownSymbol, std::set < StateType > finalStates );
@@ -146,7 +146,7 @@ public:
* @throws AutomatonException when some part of the transition is not present
* in the SinglePopNPDA (state, input symbol, stack symbol) or when transition already exists
*/
- bool addTransition ( StateType from, std::variant < EpsilonType, InputSymbolType > input, PushdownStoreSymbolType pop, StateType to, std::vector < PushdownStoreSymbolType > push );
+ bool addTransition ( StateType from, ext::variant < EpsilonType, InputSymbolType > input, PushdownStoreSymbolType pop, StateType to, std::vector < PushdownStoreSymbolType > push );
bool addTransition ( StateType from, InputSymbolType input, PushdownStoreSymbolType pop, StateType to, std::vector < PushdownStoreSymbolType > push );
@@ -158,7 +158,7 @@ public:
* @throws AutomatonException when some part of the transition is not present
* in the SinglePopNPDA (state, input symbol, stack symbol) or when transition already exists
*/
- void addTransitions ( StateType from, std::variant < EpsilonType, InputSymbolType > input, PushdownStoreSymbolType pop, std::set < std::pair < StateType, std::vector < PushdownStoreSymbolType > > > push );
+ void addTransitions ( StateType from, ext::variant < EpsilonType, InputSymbolType > input, PushdownStoreSymbolType pop, std::set < std::pair < StateType, std::vector < PushdownStoreSymbolType > > > push );
void addTransitions ( StateType from, InputSymbolType input, PushdownStoreSymbolType pop, std::set < std::pair < StateType, std::vector < PushdownStoreSymbolType > > > push );
@@ -169,7 +169,7 @@ public:
* @param transition transition to remove
* @throws AutomatonException when transition is not present in the SinglePopNPDA
*/
- bool removeTransition ( const StateType & from, const std::variant < EpsilonType, InputSymbolType > & input, const PushdownStoreSymbolType & pop, const StateType & to, const std::vector < PushdownStoreSymbolType > & push );
+ bool removeTransition ( const StateType & from, const ext::variant < EpsilonType, InputSymbolType > & input, const PushdownStoreSymbolType & pop, const StateType & to, const std::vector < PushdownStoreSymbolType > & push );
bool removeTransition ( const StateType & from, const InputSymbolType & input, const PushdownStoreSymbolType & pop, const StateType & to, const std::vector < PushdownStoreSymbolType > & push );
@@ -178,7 +178,7 @@ public:
/**
* @return SinglePopNPDA transitions
*/
- const std::map < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, std::set < std::pair < StateType, std::vector < PushdownStoreSymbolType > > > > & getTransitions ( ) const;
+ const std::map < std::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, std::set < std::pair < StateType, std::vector < PushdownStoreSymbolType > > > > & getTransitions ( ) const;
virtual int compare ( const ObjectBase & other ) const {
if ( std::type_index ( typeid ( * this ) ) == std::type_index ( typeid ( other ) ) ) return this->compare ( ( decltype ( * this ) )other );
@@ -221,14 +221,14 @@ public:
SinglePopNPDA < > * res = new SinglePopNPDA < > ( std::move ( states ), std::move ( alphabet ), std::move ( pushdownAlphabet ), std::move ( initialState ), std::move ( bottomSymbol ), std::move ( finalStates ) );
- for ( std::pair < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, std::set < std::pair < StateType, std::vector < PushdownStoreSymbolType > > > > && transition : std::make_moveable_map ( transitions ) ) {
+ for ( std::pair < std::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, std::set < std::pair < StateType, std::vector < PushdownStoreSymbolType > > > > && transition : std::make_moveable_map ( transitions ) ) {
std::set < std::pair < DefaultStateType, std::vector < DefaultSymbolType > > > targets;
for ( std::pair < StateType, std::vector < PushdownStoreSymbolType > > && target : std::make_moveable_set ( transition.second ) )
targets.insert ( std::make_pair ( AutomatonNormalize::normalizeState ( std::move ( target.first ) ), alphabet::SymbolNormalize::normalizeSymbols ( std::move ( target.second ) ) ) );
DefaultSymbolType pop = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( std::get < 2 > ( transition.first ) ) );
DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( std::get < 0 > ( transition.first ) ) );
- std::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( std::get < 1 > ( transition.first ) ) );
+ ext::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( std::get < 1 > ( transition.first ) ) );
res->addTransitions ( std::move ( from ), std::move ( input ), std::move ( pop ), std::move ( targets ) );
}
@@ -256,7 +256,7 @@ AutomatonBase* SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbol
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-bool SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransition(StateType from, std::variant < EpsilonType, InputSymbolType > input, PushdownStoreSymbolType pop, StateType to, std::vector<PushdownStoreSymbolType> push) {
+bool SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransition(StateType from, ext::variant < EpsilonType, InputSymbolType > input, PushdownStoreSymbolType pop, StateType to, std::vector<PushdownStoreSymbolType> push) {
if (! getStates().count(from)) {
throw AutomatonException("State \"" + ext::to_string ( from ) + "\" doesn't exist.");
}
@@ -279,7 +279,7 @@ bool SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, Stat
}
}
- std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType> key(std::move(from), std::move(input), std::move(pop));
+ std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType> key(std::move(from), std::move(input), std::move(pop));
std::pair<StateType, std::vector<PushdownStoreSymbolType> > value = std::make_pair(std::move(to), std::move(push));
return transitions[std::move(key)].insert(std::move(value)).second;
@@ -287,18 +287,18 @@ bool SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, Stat
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransition(StateType from, InputSymbolType input, PushdownStoreSymbolType pop, StateType to, std::vector<PushdownStoreSymbolType> push) {
- std::variant < EpsilonType, InputSymbolType > inputVariant(std::move(input));
+ ext::variant < EpsilonType, InputSymbolType > inputVariant(std::move(input));
return addTransition(std::move(from), std::move(inputVariant), std::move(pop), std::move(to), std::move(push));
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransition(StateType from, PushdownStoreSymbolType pop, StateType to, std::vector<PushdownStoreSymbolType> push) {
- auto inputVariant = std::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
+ auto inputVariant = ext::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
return addTransition(std::move(from), std::move(inputVariant), std::move(pop), std::move(to), std::move(push));
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-void SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransitions(StateType from, std::variant < EpsilonType, InputSymbolType > input, PushdownStoreSymbolType pop, std::set < std::pair < StateType, std::vector < PushdownStoreSymbolType > > > targets ) {
+void SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransitions(StateType from, ext::variant < EpsilonType, InputSymbolType > input, PushdownStoreSymbolType pop, std::set < std::pair < StateType, std::vector < PushdownStoreSymbolType > > > targets ) {
if (! getStates().count(from))
throw AutomatonException("State \"" + ext::to_string ( from ) + "\" doesn't exist.");
@@ -317,25 +317,25 @@ void SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, Stat
throw AutomatonException("Pushdown store symbol \"" + ext::to_string ( pushSymbol ) + "\" doesn't exist.");
}
- std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType> key(std::move(from), std::move(input), std::move(pop));
+ std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType> key(std::move(from), std::move(input), std::move(pop));
transitions [ std::move ( key ) ].insert ( std::make_moveable_set ( targets ).begin ( ), std::make_moveable_set ( targets ).end ( ) );
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
void SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransitions(StateType from, InputSymbolType input, PushdownStoreSymbolType pop, std::set < std::pair < StateType, std::vector < PushdownStoreSymbolType > > > targets) {
- std::variant < EpsilonType, InputSymbolType > inputVariant(std::move(input));
+ ext::variant < EpsilonType, InputSymbolType > inputVariant(std::move(input));
addTransitions(std::move(from), std::move(inputVariant), std::move(pop), std::move ( targets ) );
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
void SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransitions(StateType from, PushdownStoreSymbolType pop, std::set < std::pair < StateType, std::vector < PushdownStoreSymbolType > > >targets ) {
- auto inputVariant = std::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
+ auto inputVariant = ext::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
addTransitions(std::move(from), std::move(inputVariant), std::move(pop), std::move ( targets ) );
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-bool SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeTransition(const StateType& from, const std::variant < EpsilonType, InputSymbolType >& input, const PushdownStoreSymbolType& pop, const StateType& to, const std::vector<PushdownStoreSymbolType>& push) {
- std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType> key(from, input, pop);
+bool SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeTransition(const StateType& from, const ext::variant < EpsilonType, InputSymbolType >& input, const PushdownStoreSymbolType& pop, const StateType& to, const std::vector<PushdownStoreSymbolType>& push) {
+ std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType> key(from, input, pop);
std::pair<StateType, std::vector<PushdownStoreSymbolType> > value = std::make_pair(to, push);
return transitions[key].erase(value);
@@ -343,18 +343,18 @@ bool SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, Stat
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeTransition(const StateType& from, const InputSymbolType& input, const PushdownStoreSymbolType& pop, const StateType& to, const std::vector<PushdownStoreSymbolType>& push) {
- std::variant < EpsilonType, InputSymbolType > inputVariant(input);
+ ext::variant < EpsilonType, InputSymbolType > inputVariant(input);
return removeTransition(from, inputVariant, pop, to, push);
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
bool SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::removeTransition(const StateType& from, const PushdownStoreSymbolType& pop, const StateType& to, const std::vector<PushdownStoreSymbolType>& push) {
- auto inputVariant = std::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
+ auto inputVariant = ext::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
return removeTransition(from, inputVariant, pop, to, push);
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-const std::map<std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, std::set<std::pair<StateType, std::vector<PushdownStoreSymbolType> > > >& SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getTransitions() const {
+const std::map<std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, std::set<std::pair<StateType, std::vector<PushdownStoreSymbolType> > > >& SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getTransitions() const {
return transitions;
}
@@ -414,7 +414,7 @@ template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolTy
void SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::parseTransition(std::deque<sax::Token>::iterator& input, SinglePopNPDA& automaton) {
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
StateType from = AutomatonFromXMLParser::parseTransitionFrom<StateType>(input);
- std::variant < EpsilonType, InputSymbolType > inputSymbol = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol<EpsilonType, InputSymbolType>(input);
+ ext::variant < EpsilonType, InputSymbolType > inputSymbol = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol<EpsilonType, InputSymbolType>(input);
PushdownStoreSymbolType pop = AutomatonFromXMLParser::parseTransitionSinglePop<PushdownStoreSymbolType>(input);
StateType to = AutomatonFromXMLParser::parseTransitionTo<StateType>(input);
std::vector<PushdownStoreSymbolType> push = AutomatonFromXMLParser::parseTransitionPush<PushdownStoreSymbolType>(input);
@@ -471,7 +471,7 @@ template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolTy
class ComponentConstraint< automaton::SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, automaton::InputAlphabet > {
public:
static bool used ( const automaton::SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & automaton, const InputSymbolType & symbol ) {
- for (const std::pair<const std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, std::set<std::pair<StateType, std::vector<PushdownStoreSymbolType> > > >& transition : automaton.getTransitions())
+ for (const std::pair<const std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, std::set<std::pair<StateType, std::vector<PushdownStoreSymbolType> > > >& transition : automaton.getTransitions())
if (std::get<1>(transition.first).template is < InputSymbolType >() && symbol == std::get<1>(transition.first).template get < InputSymbolType >())
return true;
@@ -493,7 +493,7 @@ public:
if(automaton.getInitialSymbol() == symbol)
return true;
- for (const std::pair<const std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, std::set<std::pair<StateType, std::vector<PushdownStoreSymbolType> > > >& transition : automaton.getTransitions()) {
+ for (const std::pair<const std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, std::set<std::pair<StateType, std::vector<PushdownStoreSymbolType> > > >& transition : automaton.getTransitions()) {
if (symbol == std::get<2>(transition.first))
return true;
@@ -534,7 +534,7 @@ public:
if ( automaton.getFinalStates ( ).count ( state ) )
return true;
- for (const std::pair<const std::tuple<StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, std::set<std::pair<StateType, std::vector<PushdownStoreSymbolType> > > >& transition : automaton.getTransitions()) {
+ for (const std::pair<const std::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, std::set<std::pair<StateType, std::vector<PushdownStoreSymbolType> > > >& transition : automaton.getTransitions()) {
if (state == std::get<0>(transition.first))
return true;
diff --git a/alib2data/src/automaton/common/AutomatonFromXMLParser.h b/alib2data/src/automaton/common/AutomatonFromXMLParser.h
index 861f030933c9e2b5601acb06fb73f22de0687914..ca13f9dcbcb92f81470c3cfc23a6f40b74ca0607 100644
--- a/alib2data/src/automaton/common/AutomatonFromXMLParser.h
+++ b/alib2data/src/automaton/common/AutomatonFromXMLParser.h
@@ -84,14 +84,14 @@ public:
template < class SymbolType >
static SymbolType parseTransitionInputSymbol(std::deque<sax::Token>::iterator& input);
template < class EpsilonType, class SymbolType >
- static std::variant<EpsilonType, SymbolType> parseTransitionInputEpsilonSymbol(std::deque<sax::Token>::iterator& input);
+ static ext::variant<EpsilonType, SymbolType> parseTransitionInputEpsilonSymbol(std::deque<sax::Token>::iterator& input);
template < class SymbolType >
static std::vector<SymbolType> parseTransitionInputSymbolMultiple(std::deque<sax::Token>::iterator& input);
template < class SymbolType >
static SymbolType parseTransitionOutputSymbol(std::deque<sax::Token>::iterator& input);
template < class EpsilonType, class SymbolType >
- static std::variant<EpsilonType, SymbolType> parseTransitionOutputEpsilonSymbol(std::deque<sax::Token>::iterator& input);
+ static ext::variant<EpsilonType, SymbolType> parseTransitionOutputEpsilonSymbol(std::deque<sax::Token>::iterator& input);
template < class SymbolType >
static std::vector<SymbolType> parseTransitionOutputSymbolMultiple(std::deque<sax::Token>::iterator& input);
@@ -422,34 +422,34 @@ SymbolType AutomatonFromXMLParser::parseTransitionOutputSymbol ( std::deque < sa
}
template < class EpsilonType, class SymbolType >
-std::variant < EpsilonType, SymbolType > AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol ( std::deque < sax::Token >::iterator & input ) {
+ext::variant < EpsilonType, SymbolType > AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol ( std::deque < sax::Token >::iterator & input ) {
sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, "input" );
if ( sax::FromXMLParserHelper::isToken ( input, sax::Token::TokenType::START_ELEMENT, "epsilon" ) ) {
- std::variant < EpsilonType, SymbolType > result = std::variant < EpsilonType, SymbolType >::template from < EpsilonType > ( );
+ ext::variant < EpsilonType, SymbolType > result = ext::variant < EpsilonType, SymbolType >::template from < EpsilonType > ( );
++input;
sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, "epsilon" );
sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, "input" );
return result;
} else {
- std::variant < EpsilonType, SymbolType > result ( alib::xmlApi < SymbolType >::parse ( input ) );
+ ext::variant < EpsilonType, SymbolType > result ( alib::xmlApi < SymbolType >::parse ( input ) );
sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, "input" );
return result;
}
}
template < class EpsilonType, class SymbolType >
-std::variant < EpsilonType, SymbolType > AutomatonFromXMLParser::parseTransitionOutputEpsilonSymbol ( std::deque < sax::Token >::iterator & input ) {
+ext::variant < EpsilonType, SymbolType > AutomatonFromXMLParser::parseTransitionOutputEpsilonSymbol ( std::deque < sax::Token >::iterator & input ) {
sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, "output" );
if ( sax::FromXMLParserHelper::isToken ( input, sax::Token::TokenType::START_ELEMENT, "epsilon" ) ) {
- std::variant < EpsilonType, SymbolType > result = std::variant < EpsilonType, SymbolType >::template from < EpsilonType > ( );
+ ext::variant < EpsilonType, SymbolType > result = ext::variant < EpsilonType, SymbolType >::template from < EpsilonType > ( );
++input;
sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, "epsilon" );
sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, "output" );
return result;
} else {
- std::variant < EpsilonType, SymbolType > result ( alib::xmlApi < SymbolType >::parse ( input ) );
+ ext::variant < EpsilonType, SymbolType > result ( alib::xmlApi < SymbolType >::parse ( input ) );
sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, "output" );
return result;
}
diff --git a/alib2data/src/automaton/common/AutomatonNormalize.h b/alib2data/src/automaton/common/AutomatonNormalize.h
index 8bfcd22e391c358957b3a5350c7cbb2b7877bd43..e4ef255a922b42c14343e06c5b2b3838f15770b7 100644
--- a/alib2data/src/automaton/common/AutomatonNormalize.h
+++ b/alib2data/src/automaton/common/AutomatonNormalize.h
@@ -41,7 +41,7 @@ public:
static DefaultStateType normalizeState ( StateType && state);
template < class EpsilonType, class SymbolType >
- static std::variant < DefaultEpsilonType, DefaultSymbolType > normalizeSymbolEpsilon ( std::variant < EpsilonType, SymbolType > && symbol );
+ static ext::variant < DefaultEpsilonType, DefaultSymbolType > normalizeSymbolEpsilon ( ext::variant < EpsilonType, SymbolType > && symbol );
template < class SymbolType >
static regexp::UnboundedRegExpStructure < DefaultSymbolType > normalizeRegExp ( regexp::UnboundedRegExpStructure < SymbolType > && regexp );
@@ -82,11 +82,11 @@ DefaultStateType AutomatonNormalize::normalizeState ( StateType && state) {
}
template < class EpsilonType, class SymbolType >
-std::variant < DefaultEpsilonType, DefaultSymbolType > AutomatonNormalize::normalizeSymbolEpsilon ( std::variant < EpsilonType, SymbolType > && symbol ) {
+ext::variant < DefaultEpsilonType, DefaultSymbolType > AutomatonNormalize::normalizeSymbolEpsilon ( ext::variant < EpsilonType, SymbolType > && symbol ) {
if ( symbol.template is < EpsilonType > ( ) )
- return std::variant < DefaultEpsilonType, DefaultSymbolType >::template from < DefaultEpsilonType > ( );
+ return ext::variant < DefaultEpsilonType, DefaultSymbolType >::template from < DefaultEpsilonType > ( );
else
- return std::variant < DefaultEpsilonType, DefaultSymbolType > ( alphabet::SymbolNormalize::normalizeSymbol ( std::move ( symbol.template get < SymbolType > ( ) ) ) );
+ return ext::variant < DefaultEpsilonType, DefaultSymbolType > ( alphabet::SymbolNormalize::normalizeSymbol ( std::move ( symbol.template get < SymbolType > ( ) ) ) );
}
template < class SymbolType >
diff --git a/alib2data/src/automaton/common/AutomatonToXMLComposer.h b/alib2data/src/automaton/common/AutomatonToXMLComposer.h
index 566d1a58828943f9bbe06da2b145d82a312b1072..bb02c87d57697ad026990a919c00e6f7de383aa7 100644
--- a/alib2data/src/automaton/common/AutomatonToXMLComposer.h
+++ b/alib2data/src/automaton/common/AutomatonToXMLComposer.h
@@ -80,13 +80,13 @@ public:
template<class SymbolType>
static void composeTransitionInputSymbol(std::deque<sax::Token>&, const SymbolType& symbol);
template<class EpsilonType, class SymbolType>
- static void composeTransitionInputEpsilonSymbol(std::deque<sax::Token>&, const std::variant<EpsilonType, SymbolType>&);
+ static void composeTransitionInputEpsilonSymbol(std::deque<sax::Token>&, const ext::variant<EpsilonType, SymbolType>&);
template<class SymbolType>
static void composeTransitionInputSymbolMultiple(std::deque<sax::Token>&, const std::vector<SymbolType>& symbols);
template<class SymbolType>
static void composeTransitionOutputSymbol(std::deque<sax::Token>&, const SymbolType& symbol);
template<class EpsilonType, class SymbolType>
- static void composeTransitionOutputEpsilonSymbol(std::deque<sax::Token>&, const std::variant<EpsilonType, SymbolType>&);
+ static void composeTransitionOutputEpsilonSymbol(std::deque<sax::Token>&, const ext::variant<EpsilonType, SymbolType>&);
template<class SymbolType>
static void composeTransitionOutputSymbolMultiple(std::deque<sax::Token>&, const std::vector<SymbolType>& symbols);
@@ -341,7 +341,7 @@ void AutomatonToXMLComposer::composeTransitionInputSymbolMultiple(std::deque<sax
}
template < class EpsilonType, class SymbolType >
-void AutomatonToXMLComposer::composeTransitionInputEpsilonSymbol(std::deque<sax::Token>& out, const std::variant<EpsilonType, SymbolType>& symbol) {
+void AutomatonToXMLComposer::composeTransitionInputEpsilonSymbol(std::deque<sax::Token>& out, const ext::variant<EpsilonType, SymbolType>& symbol) {
out.emplace_back("input", sax::Token::TokenType::START_ELEMENT);
if(symbol.template is<EpsilonType>()) {
out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
@@ -353,7 +353,7 @@ void AutomatonToXMLComposer::composeTransitionInputEpsilonSymbol(std::deque<sax:
}
template < class EpsilonType, class SymbolType >
-void AutomatonToXMLComposer::composeTransitionOutputEpsilonSymbol(std::deque<sax::Token>& out, const std::variant<EpsilonType, SymbolType>& symbol) {
+void AutomatonToXMLComposer::composeTransitionOutputEpsilonSymbol(std::deque<sax::Token>& out, const ext::variant<EpsilonType, SymbolType>& symbol) {
out.emplace_back("output", sax::Token::TokenType::START_ELEMENT);
if(symbol.template is<EpsilonType>()) {
out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
diff --git a/alib2data/src/grammar/ContextFree/CNF.h b/alib2data/src/grammar/ContextFree/CNF.h
index fe31f6b744e752cd9fb874b6a783cfb1631be174..fd0ec94710d4dd44763f9bf11010bdfdd9e56823 100644
--- a/alib2data/src/grammar/ContextFree/CNF.h
+++ b/alib2data/src/grammar/ContextFree/CNF.h
@@ -37,7 +37,7 @@ class InitialSymbol;
template < class SymbolType >
class CNF final : public GrammarBase, public alib::Components < CNF < SymbolType >, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
- std::map < SymbolType, std::set < std::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > rules;
+ std::map < SymbolType, std::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > rules;
bool generatesEpsilon;
public:
@@ -49,15 +49,15 @@ public:
virtual GrammarBase * plunder ( ) &&;
- bool addRule ( SymbolType leftHandSide, std::variant < SymbolType, std::pair < SymbolType, SymbolType > > rightHandSide );
+ bool addRule ( SymbolType leftHandSide, ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rightHandSide );
bool addRule ( SymbolType leftHandSide, SymbolType rightHandSide );
bool addRule ( SymbolType leftHandSide, std::pair < SymbolType, SymbolType > rightHandSide );
- void addRules ( SymbolType leftHandSide, std::set < std::variant < SymbolType, std::pair < SymbolType, SymbolType > > > rightHandSide );
+ void addRules ( SymbolType leftHandSide, std::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > rightHandSide );
- const std::map < SymbolType, std::set < std::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & getRules ( ) const;
+ const std::map < SymbolType, std::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & getRules ( ) const;
- bool removeRule ( const SymbolType & leftHandSide, const std::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rightHandSide );
+ bool removeRule ( const SymbolType & leftHandSide, const ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rightHandSide );
bool removeRule ( const SymbolType & leftHandSide, const SymbolType & rightHandSide );
bool removeRule ( const SymbolType & leftHandSide, const std::pair < SymbolType, SymbolType > & rightHandSide );
@@ -140,10 +140,10 @@ public:
CNF < > * res = new CNF < > ( std::move ( nonterminals ), std::move ( terminals ), std::move ( initialSymbol ) );
- for ( std::pair < SymbolType, std::set < std::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > && rule : std::make_moveable_map ( rules ) ) {
+ for ( std::pair < SymbolType, std::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > && rule : std::make_moveable_map ( rules ) ) {
- std::set < std::variant < DefaultSymbolType, std::pair < DefaultSymbolType, DefaultSymbolType > > > rhs;
- for ( std::variant < SymbolType, std::pair < SymbolType, SymbolType > > && target : std::make_moveable_set ( rule.second ) )
+ std::set < ext::variant < DefaultSymbolType, std::pair < DefaultSymbolType, DefaultSymbolType > > > rhs;
+ for ( ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > && target : std::make_moveable_set ( rule.second ) )
rhs.insert ( GrammarNormalize::normalizeRHS ( std::move ( target ) ) );
DefaultSymbolType lhs = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( rule.first ) );
@@ -176,7 +176,7 @@ GrammarBase * CNF < SymbolType >::plunder ( ) && {
}
template < class SymbolType >
-bool CNF < SymbolType >::addRule ( SymbolType leftHandSide, std::variant < SymbolType, std::pair < SymbolType, SymbolType > > rightHandSide ) {
+bool CNF < SymbolType >::addRule ( SymbolType leftHandSide, ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rightHandSide ) {
if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
throw GrammarException ( "Rule must rewrite nonterminal symbol" );
@@ -198,24 +198,24 @@ bool CNF < SymbolType >::addRule ( SymbolType leftHandSide, std::variant < Symbo
template < class SymbolType >
bool CNF < SymbolType >::addRule ( SymbolType leftHandSide, SymbolType rightHandSide ) {
- std::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( std::move ( rightHandSide ) );
+ ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( std::move ( rightHandSide ) );
return addRule ( std::move ( leftHandSide ), std::move ( rhs ) );
}
template < class SymbolType >
bool CNF < SymbolType >::addRule ( SymbolType leftHandSide, std::pair < SymbolType, SymbolType > rightHandSide ) {
- std::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( std::move ( rightHandSide ) );
+ ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( std::move ( rightHandSide ) );
return addRule ( std::move ( leftHandSide ), std::move ( rhs ) );
}
template < class SymbolType >
-void CNF < SymbolType >::addRules ( SymbolType leftHandSide, std::set < std::variant < SymbolType, std::pair < SymbolType, SymbolType > > > rightHandSide ) {
+void CNF < SymbolType >::addRules ( SymbolType leftHandSide, std::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > rightHandSide ) {
if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
throw GrammarException ( "Rule must rewrite nonterminal symbol" );
- for ( const std::variant < SymbolType, std::pair < SymbolType, SymbolType > > & element : rightHandSide ) {
+ for ( const ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > & element : rightHandSide ) {
if ( element.template is < SymbolType > ( ) ) {
if ( !getTerminalAlphabet ( ).count ( element.template get < SymbolType > ( ) ) )
throw GrammarException ( "Rule must rewrite to terminal symbol" );
@@ -234,25 +234,25 @@ void CNF < SymbolType >::addRules ( SymbolType leftHandSide, std::set < std::var
}
template < class SymbolType >
-const std::map < SymbolType, std::set < std::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & CNF < SymbolType >::getRules ( ) const {
+const std::map < SymbolType, std::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & CNF < SymbolType >::getRules ( ) const {
return rules;
}
template < class SymbolType >
-bool CNF < SymbolType >::removeRule ( const SymbolType & leftHandSide, const std::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rightHandSide ) {
+bool CNF < SymbolType >::removeRule ( const SymbolType & leftHandSide, const ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rightHandSide ) {
return rules[leftHandSide].erase ( rightHandSide );
}
template < class SymbolType >
bool CNF < SymbolType >::removeRule ( const SymbolType & leftHandSide, const SymbolType & rightHandSide ) {
- std::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( rightHandSide );
+ ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( rightHandSide );
return removeRule ( leftHandSide, rhs );
}
template < class SymbolType >
bool CNF < SymbolType >::removeRule ( const SymbolType & leftHandSide, const std::pair < SymbolType, SymbolType > & rightHandSide ) {
- std::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( rightHandSide );
+ ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( rightHandSide );
return removeRule ( leftHandSide, rhs );
}
@@ -375,7 +375,7 @@ CNF < SymbolType > CNF < SymbolType >::parse ( std::deque < sax::Token >::iterat
template < class SymbolType >
void CNF < SymbolType >::parseRule ( std::deque < sax::Token >::iterator & input, CNF & grammar ) {
SymbolType lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS < SymbolType > ( input );
- std::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs = GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS < SymbolType > ( input );
+ ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs = GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS < SymbolType > ( input );
grammar.addRule ( std::move ( lhs ), std::move ( rhs ) );
}
@@ -424,8 +424,8 @@ template < class SymbolType >
class ComponentConstraint< grammar::CNF < SymbolType >, SymbolType, grammar::TerminalAlphabet > {
public:
static bool used ( const grammar::CNF < SymbolType > & grammar, const SymbolType & symbol ) {
- for ( const std::pair < const SymbolType, std::set < std::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & rule : grammar.getRules ( ) )
- for ( const std::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rhs : rule.second )
+ for ( const std::pair < const SymbolType, std::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & rule : grammar.getRules ( ) )
+ for ( const ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rhs : rule.second )
if ( ( rhs.template is < SymbolType > ( ) && ( rhs.template get < SymbolType > ( ) == symbol ) ) || ( rhs.template get < std::pair < SymbolType, SymbolType > > ( ).first == symbol ) )
return true;
@@ -446,11 +446,11 @@ template < class SymbolType >
class ComponentConstraint< grammar::CNF < SymbolType >, SymbolType, grammar::NonterminalAlphabet > {
public:
static bool used ( const grammar::CNF < SymbolType > & grammar, const SymbolType & symbol ) {
- for ( const std::pair < const SymbolType, std::set < std::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & rule : grammar.getRules ( ) ) {
+ for ( const std::pair < const SymbolType, std::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & rule : grammar.getRules ( ) ) {
if ( rule.first == symbol )
return true;
- for ( const std::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rhs : rule.second )
+ for ( const ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rhs : rule.second )
if ( rhs.template get < std::pair < SymbolType, SymbolType > > ( ).second == symbol )
return true;
diff --git a/alib2data/src/grammar/ContextFree/LG.h b/alib2data/src/grammar/ContextFree/LG.h
index 4baf568306da75766734b8324876a420d03dddce..1fdffbe7babd5b13573cb5fa74ddb131dff5e1f3 100644
--- a/alib2data/src/grammar/ContextFree/LG.h
+++ b/alib2data/src/grammar/ContextFree/LG.h
@@ -38,7 +38,7 @@ class InitialSymbol;
template < class SymbolType >
class LG final : public GrammarBase, public alib::Components < LG < SymbolType >, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
- std::map < SymbolType, std::set < std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > > > rules;
+ std::map < SymbolType, std::set < ext::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > > > rules;
public:
explicit LG ( SymbolType initialSymbol );
@@ -49,15 +49,15 @@ public:
virtual GrammarBase * plunder ( ) &&;
- bool addRule ( SymbolType leftHandSide, std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > rightHandSide );
+ bool addRule ( SymbolType leftHandSide, ext::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > rightHandSide );
bool addRule ( SymbolType leftHandSide, std::vector < SymbolType > rightHandSide );
bool addRule ( SymbolType leftHandSide, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > rightHandSide );
- void addRules ( SymbolType leftHandSide, std::set < std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > > rightHandSide );
+ void addRules ( SymbolType leftHandSide, std::set < ext::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > > rightHandSide );
- const std::map < SymbolType, std::set < std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > > > & getRules ( ) const;
+ const std::map < SymbolType, std::set < ext::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > > > & getRules ( ) const;
- bool removeRule ( const SymbolType & leftHandSide, const std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > & rightHandSide );
+ bool removeRule ( const SymbolType & leftHandSide, const ext::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > & rightHandSide );
bool removeRule ( const SymbolType & leftHandSide, const std::vector < SymbolType > & rightHandSide );
bool removeRule ( const SymbolType & leftHandSide, const std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > & rightHandSide );
@@ -137,10 +137,10 @@ public:
LG < > * res = new LG < > ( std::move ( nonterminals ), std::move ( terminals ), std::move ( initialSymbol ) );
- for ( std::pair < SymbolType, std::set < std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > > > && rule : std::make_moveable_map ( rules ) ) {
+ for ( std::pair < SymbolType, std::set < ext::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > > > && rule : std::make_moveable_map ( rules ) ) {
- std::set < std::variant < std::vector < DefaultSymbolType >, std::tuple < std::vector < DefaultSymbolType >, DefaultSymbolType, std::vector < DefaultSymbolType > > > > rhs;
- for ( std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > && target : std::make_moveable_set ( rule.second ) )
+ std::set < ext::variant < std::vector < DefaultSymbolType >, std::tuple < std::vector < DefaultSymbolType >, DefaultSymbolType, std::vector < DefaultSymbolType > > > > rhs;
+ for ( ext::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > && target : std::make_moveable_set ( rule.second ) )
rhs.insert ( GrammarNormalize::normalizeRHS ( std::move ( target ) ) );
DefaultSymbolType lhs = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( rule.first ) );
@@ -171,7 +171,7 @@ GrammarBase * LG < SymbolType >::plunder ( ) && {
}
template < class SymbolType >
-bool LG < SymbolType >::addRule ( SymbolType leftHandSide, std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > rightHandSide ) {
+bool LG < SymbolType >::addRule ( SymbolType leftHandSide, ext::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > rightHandSide ) {
if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
throw GrammarException ( "Rule must rewrite nonterminal symbol" );
@@ -201,24 +201,24 @@ bool LG < SymbolType >::addRule ( SymbolType leftHandSide, std::variant < std::v
template < class SymbolType >
bool LG < SymbolType >::addRule ( SymbolType leftHandSide, std::vector < SymbolType > rightHandSide ) {
- std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > rhs ( std::move ( rightHandSide ) );
+ ext::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > rhs ( std::move ( rightHandSide ) );
return addRule ( std::move ( leftHandSide ), std::move ( rhs ) );
}
template < class SymbolType >
bool LG < SymbolType >::addRule ( SymbolType leftHandSide, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > rightHandSide ) {
- std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > rhs ( std::move ( rightHandSide ) );
+ ext::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > rhs ( std::move ( rightHandSide ) );
return addRule ( std::move ( leftHandSide ), std::move ( rhs ) );
}
template < class SymbolType >
-void LG < SymbolType >::addRules ( SymbolType leftHandSide, std::set < std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > > rightHandSide ) {
+void LG < SymbolType >::addRules ( SymbolType leftHandSide, std::set < ext::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > > rightHandSide ) {
if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
throw GrammarException ( "Rule must rewrite nonterminal symbol" );
- for ( const std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > & element : rightHandSide ) {
+ for ( const ext::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > & element : rightHandSide ) {
if ( element.template is < std::vector < SymbolType > > ( ) ) {
const std::vector < SymbolType > & rhs = element.template get < std::vector < SymbolType > > ( );
@@ -245,25 +245,25 @@ void LG < SymbolType >::addRules ( SymbolType leftHandSide, std::set < std::vari
}
template < class SymbolType >
-const std::map < SymbolType, std::set < std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > > > & LG < SymbolType >::getRules ( ) const {
+const std::map < SymbolType, std::set < ext::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > > > & LG < SymbolType >::getRules ( ) const {
return rules;
}
template < class SymbolType >
-bool LG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > & rightHandSide ) {
+bool LG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const ext::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > & rightHandSide ) {
return rules[leftHandSide].erase ( rightHandSide );
}
template < class SymbolType >
bool LG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const std::vector < SymbolType > & rightHandSide ) {
- std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > rhs ( rightHandSide );
+ ext::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > rhs ( rightHandSide );
return removeRule ( leftHandSide, rhs );
}
template < class SymbolType >
bool LG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > & rightHandSide ) {
- std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > rhs ( rightHandSide );
+ ext::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > rhs ( rightHandSide );
return removeRule ( leftHandSide, rhs );
}
@@ -410,8 +410,8 @@ template < class SymbolType >
class ComponentConstraint< grammar::LG < SymbolType >, SymbolType, grammar::TerminalAlphabet > {
public:
static bool used ( const grammar::LG < SymbolType > & grammar, const SymbolType & symbol ) {
- for ( const std::pair < const SymbolType, std::set < std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > > > & rule : grammar.getRules ( ) ) {
- for ( const std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > & rhsTmp : rule.second )
+ for ( const std::pair < const SymbolType, std::set < ext::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > > > & rule : grammar.getRules ( ) ) {
+ for ( const ext::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > & rhsTmp : rule.second )
if ( rhsTmp.template is < std::vector < SymbolType > > ( ) ) {
const std::vector < SymbolType > & rhs = rhsTmp.template get < std::vector < SymbolType > > ( );
@@ -450,11 +450,11 @@ template < class SymbolType >
class ComponentConstraint< grammar::LG < SymbolType >, SymbolType, grammar::NonterminalAlphabet > {
public:
static bool used ( const grammar::LG < SymbolType > & grammar, const SymbolType & symbol ) {
- for ( const std::pair < const SymbolType, std::set < std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > > > & rule : grammar.getRules ( ) ) {
+ for ( const std::pair < const SymbolType, std::set < ext::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > > > & rule : grammar.getRules ( ) ) {
if ( rule.first == symbol )
return true;
- for ( const std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > & rhsTmp : rule.second )
+ for ( const ext::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > & rhsTmp : rule.second )
if ( rhsTmp.template is < std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > ( ) ) {
const std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > & rhs = rhsTmp.template get < std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > ( );
diff --git a/alib2data/src/grammar/Regular/LeftLG.h b/alib2data/src/grammar/Regular/LeftLG.h
index cb5f37ebb459ec69384698082c610cb905a0c38a..83fb9f85a0ce7a1af8ba5fc54f3c6139d3f3d18d 100644
--- a/alib2data/src/grammar/Regular/LeftLG.h
+++ b/alib2data/src/grammar/Regular/LeftLG.h
@@ -67,7 +67,7 @@ class LeftLG final : public GrammarBase, public alib::Components < LeftLG < Symb
/**
* Rules as mapping from nonterminal symbol on the left hand side to set of either sequence of terminal symbols or doublets of sequence of terminal symbols and nonterminal symbol.
*/
- std::map < SymbolType, std::set < std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > > > rules;
+ std::map < SymbolType, std::set < ext::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > > > rules;
public:
/**
@@ -106,7 +106,7 @@ public:
*
* \returns true if the rule was indeed added, false othervise
*/
- bool addRule ( SymbolType leftHandSide, std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > rightHandSide );
+ bool addRule ( SymbolType leftHandSide, ext::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > rightHandSide );
/**
* \brief Add a new rule of a grammar.
@@ -140,14 +140,14 @@ public:
* \param leftHandSide the left hand side of the rule
* \param rightHandSide a set of right hand sides of the rule
*/
- void addRules ( SymbolType leftHandSide, std::set < std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > > rightHandSide );
+ void addRules ( SymbolType leftHandSide, std::set < ext::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > > rightHandSide );
/**
* Get rules of the grammar.
*
* \returns rules of the grammar
*/
- const std::map < SymbolType, std::set < std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > > > & getRules ( ) const;
+ const std::map < SymbolType, std::set < ext::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > > > & getRules ( ) const;
/**
* Remove a rule of a grammar in form of A -> aB or A -> a, where A, B \in N and a \in T*.
@@ -157,7 +157,7 @@ public:
*
* \returns true if the rule was indeed removed, false othervise
*/
- bool removeRule ( const SymbolType & leftHandSide, const std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > & rightHandSide );
+ bool removeRule ( const SymbolType & leftHandSide, const ext::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > & rightHandSide );
/**
* Remove a rule of a grammar in form of A -> a, where A \in N and a \in T*.
@@ -378,10 +378,10 @@ public:
LeftLG < > * res = new LeftLG < > ( std::move ( nonterminals ), std::move ( terminals ), std::move ( initialSymbol ) );
- for ( std::pair < SymbolType, std::set < std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > > > && rule : std::make_moveable_map ( rules ) ) {
+ for ( std::pair < SymbolType, std::set < ext::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > > > && rule : std::make_moveable_map ( rules ) ) {
- std::set < std::variant < std::vector < DefaultSymbolType >, std::pair < DefaultSymbolType, std::vector < DefaultSymbolType > > > > rhs;
- for ( std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > && target : std::make_moveable_set ( rule.second ) )
+ std::set < ext::variant < std::vector < DefaultSymbolType >, std::pair < DefaultSymbolType, std::vector < DefaultSymbolType > > > > rhs;
+ for ( ext::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > && target : std::make_moveable_set ( rule.second ) )
rhs.insert ( GrammarNormalize::normalizeRHS ( std::move ( target ) ) );
DefaultSymbolType lhs = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( rule.first ) );
@@ -413,7 +413,7 @@ GrammarBase * LeftLG < SymbolType >::plunder ( ) && {
}
template < class SymbolType >
-bool LeftLG < SymbolType >::addRule ( SymbolType leftHandSide, std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > rightHandSide ) {
+bool LeftLG < SymbolType >::addRule ( SymbolType leftHandSide, ext::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > rightHandSide ) {
if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
throw GrammarException ( "Rule must rewrite nonterminal symbol" );
@@ -437,24 +437,24 @@ bool LeftLG < SymbolType >::addRule ( SymbolType leftHandSide, std::variant < st
template < class SymbolType >
bool LeftLG < SymbolType >::addRule ( SymbolType leftHandSide, std::vector < SymbolType > rightHandSide ) {
- std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > rhs ( std::move ( rightHandSide ) );
+ ext::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > rhs ( std::move ( rightHandSide ) );
return addRule ( std::move ( leftHandSide ), std::move ( rhs ) );
}
template < class SymbolType >
bool LeftLG < SymbolType >::addRule ( SymbolType leftHandSide, std::pair < SymbolType, std::vector < SymbolType > > rightHandSide ) {
- std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > rhs ( std::move ( rightHandSide ) );
+ ext::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > rhs ( std::move ( rightHandSide ) );
return addRule ( std::move ( leftHandSide ), std::move ( rhs ) );
}
template < class SymbolType >
-void LeftLG < SymbolType >::addRules ( SymbolType leftHandSide, std::set < std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > > rightHandSide ) {
+void LeftLG < SymbolType >::addRules ( SymbolType leftHandSide, std::set < ext::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > > rightHandSide ) {
if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
throw GrammarException ( "Rule must rewrite nonterminal symbol" );
- for ( const std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > & element : rightHandSide ) {
+ for ( const ext::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > & element : rightHandSide ) {
if ( element.template is < std::vector < SymbolType > > ( ) ) {
for ( const auto & symbol : element.template get < std::vector < SymbolType > > ( ) )
if ( !getTerminalAlphabet ( ).count ( symbol ) )
@@ -477,25 +477,25 @@ void LeftLG < SymbolType >::addRules ( SymbolType leftHandSide, std::set < std::
}
template < class SymbolType >
-const std::map < SymbolType, std::set < std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > > > & LeftLG < SymbolType >::getRules ( ) const {
+const std::map < SymbolType, std::set < ext::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > > > & LeftLG < SymbolType >::getRules ( ) const {
return rules;
}
template < class SymbolType >
-bool LeftLG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > & rightHandSide ) {
+bool LeftLG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const ext::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > & rightHandSide ) {
return rules[leftHandSide].erase ( rightHandSide );
}
template < class SymbolType >
bool LeftLG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const std::vector < SymbolType > & rightHandSide ) {
- std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > rhs ( rightHandSide );
+ ext::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > rhs ( rightHandSide );
return removeRule ( leftHandSide, rhs );
}
template < class SymbolType >
bool LeftLG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const std::pair < SymbolType, std::vector < SymbolType > > & rightHandSide ) {
- std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > rhs ( rightHandSide );
+ ext::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > rhs ( rightHandSide );
return removeRule ( leftHandSide, rhs );
}
@@ -648,8 +648,8 @@ public:
* \returns true if the symbol is used, false othervise
*/
static bool used ( const grammar::LeftLG < SymbolType > & grammar, const SymbolType & symbol ) {
- for ( const std::pair < const SymbolType, std::set < std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > > > & rule : grammar.getRules ( ) ) {
- for ( const std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > & rhsTmp : rule.second )
+ for ( const std::pair < const SymbolType, std::set < ext::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > > > & rule : grammar.getRules ( ) ) {
+ for ( const ext::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > & rhsTmp : rule.second )
if ( rhsTmp.template is < std::vector < SymbolType > > ( ) ) {
const std::vector < SymbolType > & rhs = rhsTmp.template get < std::vector < SymbolType > > ( );
@@ -707,11 +707,11 @@ public:
* \returns true if the symbol is used, false othervise
*/
static bool used ( const grammar::LeftLG < SymbolType > & grammar, const SymbolType & symbol ) {
- for ( const std::pair < const SymbolType, std::set < std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > > > & rule : grammar.getRules ( ) ) {
+ for ( const std::pair < const SymbolType, std::set < ext::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > > > & rule : grammar.getRules ( ) ) {
if ( rule.first == symbol )
return true;
- for ( const std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > & rhsTmp : rule.second )
+ for ( const ext::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > & rhsTmp : rule.second )
if ( rhsTmp.template is < std::pair < SymbolType, std::vector < SymbolType > > > ( ) ) {
const std::pair < SymbolType, std::vector < SymbolType > > & rhs = rhsTmp.template get < std::pair < SymbolType, std::vector < SymbolType > > > ( );
diff --git a/alib2data/src/grammar/Regular/LeftRG.h b/alib2data/src/grammar/Regular/LeftRG.h
index 7c3e0d3adabf7d38c1bc933bb04c799dc84a0761..716e984503b6312702024ab06017c085cbad68c7 100644
--- a/alib2data/src/grammar/Regular/LeftRG.h
+++ b/alib2data/src/grammar/Regular/LeftRG.h
@@ -71,7 +71,7 @@ class LeftRG final : public GrammarBase, public alib::Components < LeftRG < Symb
/**
* Rules as mapping from nonterminal symbol on the left hand side to set of either terminal symbols or doublets of terminal symbol and nonterminal symbol.
*/
- std::map < SymbolType, std::set < std::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > rules;
+ std::map < SymbolType, std::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > rules;
/**
* Boolean signaling whether grammar generates empty string or don't.
@@ -115,7 +115,7 @@ public:
*
* \returns true if the rule was indeed added, false othervise
*/
- bool addRule ( SymbolType leftHandSide, std::variant < SymbolType, std::pair < SymbolType, SymbolType > > rightHandSide );
+ bool addRule ( SymbolType leftHandSide, ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rightHandSide );
/**
* \brief Add a new rule of a grammar.
@@ -149,14 +149,14 @@ public:
* \param leftHandSide the left hand side of the rule
* \param rightHandSide a set of right hand sides of the rule
*/
- void addRules ( SymbolType leftHandSide, std::set < std::variant < SymbolType, std::pair < SymbolType, SymbolType > > > rightHandSide );
+ void addRules ( SymbolType leftHandSide, std::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > rightHandSide );
/**
* Get rules of the grammar.
*
* \returns rules of the grammar
*/
- const std::map < SymbolType, std::set < std::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & getRules ( ) const;
+ const std::map < SymbolType, std::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & getRules ( ) const;
/**
* Remove a rule of a grammar in form of A -> aB or A -> a, where A, B \in N and a \in T.
@@ -166,7 +166,7 @@ public:
*
* \returns true if the rule was indeed removed, false othervise
*/
- bool removeRule ( const SymbolType & leftHandSide, const std::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rightHandSide );
+ bool removeRule ( const SymbolType & leftHandSide, const ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rightHandSide );
/**
* Remove a rule of a grammar in form of A -> a, where A \in N and a \in T.
@@ -401,10 +401,10 @@ public:
LeftRG < > * res = new LeftRG < > ( std::move ( nonterminals ), std::move ( terminals ), std::move ( initialSymbol ) );
- for ( std::pair < SymbolType, std::set < std::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > && rule : std::make_moveable_map ( rules ) ) {
+ for ( std::pair < SymbolType, std::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > && rule : std::make_moveable_map ( rules ) ) {
- std::set < std::variant < DefaultSymbolType, std::pair < DefaultSymbolType, DefaultSymbolType > > > rhs;
- for ( std::variant < SymbolType, std::pair < SymbolType, SymbolType > > && target : std::make_moveable_set ( rule.second ) )
+ std::set < ext::variant < DefaultSymbolType, std::pair < DefaultSymbolType, DefaultSymbolType > > > rhs;
+ for ( ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > && target : std::make_moveable_set ( rule.second ) )
rhs.insert ( GrammarNormalize::normalizeRHS ( std::move ( target ) ) );
DefaultSymbolType lhs = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( rule.first ) );
@@ -437,7 +437,7 @@ GrammarBase * LeftRG < SymbolType >::plunder ( ) && {
}
template < class SymbolType >
-bool LeftRG < SymbolType >::addRule ( SymbolType leftHandSide, std::variant < SymbolType, std::pair < SymbolType, SymbolType > > rightHandSide ) {
+bool LeftRG < SymbolType >::addRule ( SymbolType leftHandSide, ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rightHandSide ) {
if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
throw GrammarException ( "Rule must rewrite nonterminal symbol" );
@@ -457,11 +457,11 @@ bool LeftRG < SymbolType >::addRule ( SymbolType leftHandSide, std::variant < Sy
}
template < class SymbolType >
-void LeftRG < SymbolType >::addRules ( SymbolType leftHandSide, std::set < std::variant < SymbolType, std::pair < SymbolType, SymbolType > > > rightHandSide ) {
+void LeftRG < SymbolType >::addRules ( SymbolType leftHandSide, std::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > rightHandSide ) {
if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
throw GrammarException ( "Rule must rewrite nonterminal symbol" );
- for ( const std::variant < SymbolType, std::pair < SymbolType, SymbolType > > & element : rightHandSide ) {
+ for ( const ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > & element : rightHandSide ) {
if ( element.template is < SymbolType > ( ) ) {
const SymbolType & rhs = element.template get < SymbolType > ( );
@@ -481,38 +481,38 @@ void LeftRG < SymbolType >::addRules ( SymbolType leftHandSide, std::set < std::
template < class SymbolType >
bool LeftRG < SymbolType >::addRule ( SymbolType leftHandSide, SymbolType rightHandSide ) {
- std::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( std::move ( rightHandSide ) );
+ ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( std::move ( rightHandSide ) );
return addRule ( std::move ( leftHandSide ), std::move ( rhs ) );
}
template < class SymbolType >
bool LeftRG < SymbolType >::addRule ( SymbolType leftHandSide, std::pair < SymbolType, SymbolType > rightHandSide ) {
- std::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( std::move ( rightHandSide ) );
+ ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( std::move ( rightHandSide ) );
return addRule ( std::move ( leftHandSide ), std::move ( rhs ) );
}
template < class SymbolType >
-const std::map < SymbolType, std::set < std::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & LeftRG < SymbolType >::getRules ( ) const {
+const std::map < SymbolType, std::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & LeftRG < SymbolType >::getRules ( ) const {
return rules;
}
template < class SymbolType >
-bool LeftRG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const std::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rightHandSide ) {
+bool LeftRG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rightHandSide ) {
return rules[leftHandSide].erase ( rightHandSide );
}
template < class SymbolType >
bool LeftRG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const SymbolType & rightHandSide ) {
- std::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( rightHandSide );
+ ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( rightHandSide );
return removeRule ( leftHandSide, rhs );
}
template < class SymbolType >
bool LeftRG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const std::pair < SymbolType, SymbolType > & rightHandSide ) {
- std::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( rightHandSide );
+ ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( rightHandSide );
return removeRule ( leftHandSide, rhs );
}
@@ -635,7 +635,7 @@ LeftRG < SymbolType > LeftRG < SymbolType >::parse ( std::deque < sax::Token >::
template < class SymbolType >
void LeftRG < SymbolType >::parseRule ( std::deque < sax::Token >::iterator & input, LeftRG & grammar ) {
SymbolType lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS < SymbolType > ( input );
- std::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs = GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS < SymbolType > ( input );
+ ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs = GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS < SymbolType > ( input );
grammar.addRule ( std::move ( lhs ), std::move ( rhs ) );
}
@@ -697,8 +697,8 @@ public:
* \returns true if the symbol is used, false othervise
*/
static bool used ( const grammar::LeftRG < SymbolType > & grammar, const SymbolType & symbol ) {
- for ( const std::pair < const SymbolType, std::set < std::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & rule : grammar.getRules ( ) )
- for ( const std::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rhs : rule.second )
+ for ( const std::pair < const SymbolType, std::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & rule : grammar.getRules ( ) )
+ for ( const ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rhs : rule.second )
if ( ( rhs.template is < SymbolType > ( ) && ( rhs.template get < SymbolType > ( ) == symbol ) ) || ( rhs.template get < std::pair < SymbolType, SymbolType > > ( ).first == symbol ) )
return true;
@@ -745,11 +745,11 @@ public:
* \returns true if the symbol is used, false othervise
*/
static bool used ( const grammar::LeftRG < SymbolType > & grammar, const SymbolType & symbol ) {
- for ( const std::pair < const SymbolType, std::set < std::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & rule : grammar.getRules ( ) ) {
+ for ( const std::pair < const SymbolType, std::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & rule : grammar.getRules ( ) ) {
if ( rule.first == symbol )
return true;
- for ( const std::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rhs : rule.second )
+ for ( const ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rhs : rule.second )
if ( rhs.template get < std::pair < SymbolType, SymbolType > > ( ).second == symbol )
return true;
diff --git a/alib2data/src/grammar/Regular/RightLG.h b/alib2data/src/grammar/Regular/RightLG.h
index c9f31d4994d49604ddb130b65bc0b1988e23a33b..e0d4e301ee5f59149fae51bd7cf8d878dda07e9c 100644
--- a/alib2data/src/grammar/Regular/RightLG.h
+++ b/alib2data/src/grammar/Regular/RightLG.h
@@ -67,7 +67,7 @@ class RightLG final : public GrammarBase, public alib::Components < RightLG < Sy
/**
* Rules as mapping from nonterminal symbol on the left hand side to set of either sequence of terminal symbols or doublets of sequence of nonterminal symbol and terminal symbols.
*/
- std::map < SymbolType, std::set < std::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > > > rules;
+ std::map < SymbolType, std::set < ext::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > > > rules;
public:
/**
@@ -106,7 +106,7 @@ public:
*
* \returns true if the rule was indeed added, false othervise
*/
- bool addRule ( SymbolType leftHandSide, std::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > rightHandSide );
+ bool addRule ( SymbolType leftHandSide, ext::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > rightHandSide );
/**
* \brief Add a new rule of a grammar.
@@ -140,14 +140,14 @@ public:
* \param leftHandSide the left hand side of the rule
* \param rightHandSide a set of right hand sides of the rule
*/
- void addRules ( SymbolType leftHandSide, std::set < std::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > > rightHandSide );
+ void addRules ( SymbolType leftHandSide, std::set < ext::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > > rightHandSide );
/**
* Get rules of the grammar.
*
* \returns rules of the grammar
*/
- const std::map < SymbolType, std::set < std::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > > > & getRules ( ) const;
+ const std::map < SymbolType, std::set < ext::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > > > & getRules ( ) const;
/**
* Remove a rule of a grammar in form of A -> Ba or A -> a, where A, B \in N and a \in T*.
@@ -157,7 +157,7 @@ public:
*
* \returns true if the rule was indeed removed, false othervise
*/
- bool removeRule ( const SymbolType & leftHandSide, const std::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > & rightHandSide );
+ bool removeRule ( const SymbolType & leftHandSide, const ext::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > & rightHandSide );
/**
* Remove a rule of a grammar in form of A -> a, where A \in N and a \in T*.
@@ -378,10 +378,10 @@ public:
RightLG < > * res = new RightLG < > ( std::move ( nonterminals ), std::move ( terminals ), std::move ( initialSymbol ) );
- for ( std::pair < SymbolType, std::set < std::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > > > && rule : std::make_moveable_map ( rules ) ) {
+ for ( std::pair < SymbolType, std::set < ext::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > > > && rule : std::make_moveable_map ( rules ) ) {
- std::set < std::variant < std::vector < DefaultSymbolType >, std::pair < std::vector < DefaultSymbolType >, DefaultSymbolType > > > rhs;
- for ( std::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > && target : std::make_moveable_set ( rule.second ) )
+ std::set < ext::variant < std::vector < DefaultSymbolType >, std::pair < std::vector < DefaultSymbolType >, DefaultSymbolType > > > rhs;
+ for ( ext::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > && target : std::make_moveable_set ( rule.second ) )
rhs.insert ( GrammarNormalize::normalizeRHS ( std::move ( target ) ) );
DefaultSymbolType lhs = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( rule.first ) );
@@ -412,7 +412,7 @@ GrammarBase * RightLG < SymbolType >::plunder ( ) && {
}
template < class SymbolType >
-bool RightLG < SymbolType >::addRule ( SymbolType leftHandSide, std::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > rightHandSide ) {
+bool RightLG < SymbolType >::addRule ( SymbolType leftHandSide, ext::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > rightHandSide ) {
if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
throw GrammarException ( "Rule must rewrite nonterminal symbol" );
@@ -436,24 +436,24 @@ bool RightLG < SymbolType >::addRule ( SymbolType leftHandSide, std::variant < s
template < class SymbolType >
bool RightLG < SymbolType >::addRule ( SymbolType leftHandSide, std::vector < SymbolType > rightHandSide ) {
- std::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > rhs ( std::move ( rightHandSide ) );
+ ext::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > rhs ( std::move ( rightHandSide ) );
return addRule ( std::move ( leftHandSide ), std::move ( rhs ) );
}
template < class SymbolType >
bool RightLG < SymbolType >::addRule ( SymbolType leftHandSide, std::pair < std::vector < SymbolType >, SymbolType > rightHandSide ) {
- std::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > rhs ( std::move ( rightHandSide ) );
+ ext::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > rhs ( std::move ( rightHandSide ) );
return addRule ( std::move ( leftHandSide ), std::move ( rhs ) );
}
template < class SymbolType >
-void RightLG < SymbolType >::addRules ( SymbolType leftHandSide, std::set < std::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > > rightHandSide ) {
+void RightLG < SymbolType >::addRules ( SymbolType leftHandSide, std::set < ext::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > > rightHandSide ) {
if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
throw GrammarException ( "Rule must rewrite nonterminal symbol" );
- for ( const std::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > & element : rightHandSide ) {
+ for ( const ext::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > & element : rightHandSide ) {
if ( element.template is < std::vector < SymbolType > > ( ) ) {
for ( const auto & symbol : element.template get < std::vector < SymbolType > > ( ) )
if ( !getTerminalAlphabet ( ).count ( symbol ) )
@@ -474,25 +474,25 @@ void RightLG < SymbolType >::addRules ( SymbolType leftHandSide, std::set < std:
}
template < class SymbolType >
-const std::map < SymbolType, std::set < std::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > > > & RightLG < SymbolType >::getRules ( ) const {
+const std::map < SymbolType, std::set < ext::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > > > & RightLG < SymbolType >::getRules ( ) const {
return rules;
}
template < class SymbolType >
-bool RightLG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const std::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > & rightHandSide ) {
+bool RightLG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const ext::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > & rightHandSide ) {
return rules[leftHandSide].erase ( rightHandSide );
}
template < class SymbolType >
bool RightLG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const std::vector < SymbolType > & rightHandSide ) {
- std::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > rhs ( rightHandSide );
+ ext::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > rhs ( rightHandSide );
return removeRule ( leftHandSide, rhs );
}
template < class SymbolType >
bool RightLG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const std::pair < std::vector < SymbolType >, SymbolType > & rightHandSide ) {
- std::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > rhs ( rightHandSide );
+ ext::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > rhs ( rightHandSide );
return removeRule ( leftHandSide, rhs );
}
@@ -645,8 +645,8 @@ public:
* \returns true if the symbol is used, false othervise
*/
static bool used ( const grammar::RightLG < SymbolType > & grammar, const SymbolType & symbol ) {
- for ( const std::pair < const SymbolType, std::set < std::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > > > & rule : grammar.getRules ( ) ) {
- for ( const std::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > & rhsTmp : rule.second )
+ for ( const std::pair < const SymbolType, std::set < ext::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > > > & rule : grammar.getRules ( ) ) {
+ for ( const ext::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > & rhsTmp : rule.second )
if ( rhsTmp.template is < std::vector < SymbolType > > ( ) ) {
const std::vector < SymbolType > & rhs = rhsTmp.template get < std::vector < SymbolType > > ( );
@@ -704,11 +704,11 @@ public:
* \returns true if the symbol is used, false othervise
*/
static bool used ( const grammar::RightLG < SymbolType > & grammar, const SymbolType & symbol ) {
- for ( const std::pair < const SymbolType, std::set < std::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > > > & rule : grammar.getRules ( ) ) {
+ for ( const std::pair < const SymbolType, std::set < ext::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > > > & rule : grammar.getRules ( ) ) {
if ( rule.first == symbol )
return true;
- for ( const std::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > & rhsTmp : rule.second )
+ for ( const ext::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > & rhsTmp : rule.second )
if ( rhsTmp.template is < std::pair < std::vector < SymbolType >, SymbolType > > ( ) ) {
const std::pair < std::vector < SymbolType >, SymbolType > & rhs = rhsTmp.template get < std::pair < std::vector < SymbolType >, SymbolType > > ( );
diff --git a/alib2data/src/grammar/Regular/RightRG.h b/alib2data/src/grammar/Regular/RightRG.h
index 769cf75b134a916acaacfce59025012dd65ddb42..d0904b731ef08ed10299e3a4b5d3f6ca4b6e9713 100644
--- a/alib2data/src/grammar/Regular/RightRG.h
+++ b/alib2data/src/grammar/Regular/RightRG.h
@@ -71,7 +71,7 @@ class RightRG final : public GrammarBase, public alib::Components < RightRG < Sy
/**
* Rules function as mapping from nonterminal symbol on the left hand side to set of either terminal symbols or doublets of nonterminal symbol and terminal symbol.
*/
- std::map < SymbolType, std::set < std::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > rules;
+ std::map < SymbolType, std::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > rules;
/**
* Boolean signaling whether grammar generates empty string or don't.
@@ -115,7 +115,7 @@ public:
*
* \returns true if the rule was indeed added, false othervise
*/
- bool addRule ( SymbolType leftHandSide, std::variant < SymbolType, std::pair < SymbolType, SymbolType > > rightHandSide );
+ bool addRule ( SymbolType leftHandSide, ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rightHandSide );
/**
* \brief Add a new rule of a grammar.
@@ -149,14 +149,14 @@ public:
* \param leftHandSide the left hand side of the rule
* \param rightHandSide a set of right hand sides of the rule
*/
- void addRules ( SymbolType leftHandSide, std::set < std::variant < SymbolType, std::pair < SymbolType, SymbolType > > > rightHandSide );
+ void addRules ( SymbolType leftHandSide, std::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > rightHandSide );
/**
* Get rules of the grammar.
*
* \returns rules of the grammar
*/
- const std::map < SymbolType, std::set < std::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & getRules ( ) const;
+ const std::map < SymbolType, std::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & getRules ( ) const;
/**
* Remove a rule of a grammar in form of A -> Ba or A -> a, where A, B \in N and a \in T.
@@ -166,7 +166,7 @@ public:
*
* \returns true if the rule was indeed removed, false othervise
*/
- bool removeRule ( const SymbolType & leftHandSide, const std::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rightHandSide );
+ bool removeRule ( const SymbolType & leftHandSide, const ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rightHandSide );
/**
* Remove a rule of a grammar in form of A -> a, where A \in N and a \in T.
@@ -401,10 +401,10 @@ public:
RightRG < > * res = new RightRG < > ( std::move ( nonterminals ), std::move ( terminals ), std::move ( initialSymbol ) );
- for ( std::pair < SymbolType, std::set < std::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > && rule : std::make_moveable_map ( rules ) ) {
+ for ( std::pair < SymbolType, std::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > && rule : std::make_moveable_map ( rules ) ) {
- std::set < std::variant < DefaultSymbolType, std::pair < DefaultSymbolType, DefaultSymbolType > > > rhs;
- for ( std::variant < SymbolType, std::pair < SymbolType, SymbolType > > && target : std::make_moveable_set ( rule.second ) )
+ std::set < ext::variant < DefaultSymbolType, std::pair < DefaultSymbolType, DefaultSymbolType > > > rhs;
+ for ( ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > && target : std::make_moveable_set ( rule.second ) )
rhs.insert ( GrammarNormalize::normalizeRHS ( std::move ( target ) ) );
DefaultSymbolType lhs = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( rule.first ) );
@@ -437,7 +437,7 @@ GrammarBase * RightRG < SymbolType >::plunder ( ) && {
}
template < class SymbolType >
-bool RightRG < SymbolType >::addRule ( SymbolType leftHandSide, std::variant < SymbolType, std::pair < SymbolType, SymbolType > > rightHandSide ) {
+bool RightRG < SymbolType >::addRule ( SymbolType leftHandSide, ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rightHandSide ) {
if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
throw GrammarException ( "Rule must rewrite nonterminal symbol" );
@@ -458,24 +458,24 @@ bool RightRG < SymbolType >::addRule ( SymbolType leftHandSide, std::variant < S
template < class SymbolType >
bool RightRG < SymbolType >::addRule ( SymbolType leftHandSide, SymbolType rightHandSide ) {
- std::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( std::move ( rightHandSide ) );
+ ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( std::move ( rightHandSide ) );
return addRule ( std::move ( leftHandSide ), std::move ( rhs ) );
}
template < class SymbolType >
bool RightRG < SymbolType >::addRule ( SymbolType leftHandSide, std::pair < SymbolType, SymbolType > rightHandSide ) {
- std::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( std::move ( rightHandSide ) );
+ ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( std::move ( rightHandSide ) );
return addRule ( std::move ( leftHandSide ), std::move ( rhs ) );
}
template < class SymbolType >
-void RightRG < SymbolType >::addRules ( SymbolType leftHandSide, std::set < std::variant < SymbolType, std::pair < SymbolType, SymbolType > > > rightHandSide ) {
+void RightRG < SymbolType >::addRules ( SymbolType leftHandSide, std::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > rightHandSide ) {
if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
throw GrammarException ( "Rule must rewrite nonterminal symbol" );
- for ( const std::variant < SymbolType, std::pair < SymbolType, SymbolType > > & element : rightHandSide ) {
+ for ( const ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > & element : rightHandSide ) {
if ( element.template is < SymbolType > ( ) ) {
const SymbolType & rhs = element.template get < SymbolType > ( );
@@ -493,25 +493,25 @@ void RightRG < SymbolType >::addRules ( SymbolType leftHandSide, std::set < std:
}
template < class SymbolType >
-const std::map < SymbolType, std::set < std::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & RightRG < SymbolType >::getRules ( ) const {
+const std::map < SymbolType, std::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & RightRG < SymbolType >::getRules ( ) const {
return rules;
}
template < class SymbolType >
-bool RightRG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const std::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rightHandSide ) {
+bool RightRG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rightHandSide ) {
return rules[leftHandSide].erase ( rightHandSide );
}
template < class SymbolType >
bool RightRG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const SymbolType & rightHandSide ) {
- std::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( rightHandSide );
+ ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( rightHandSide );
return removeRule ( leftHandSide, rhs );
}
template < class SymbolType >
bool RightRG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const std::pair < SymbolType, SymbolType > & rightHandSide ) {
- std::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( rightHandSide );
+ ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( rightHandSide );
return removeRule ( leftHandSide, rhs );
}
@@ -632,7 +632,7 @@ RightRG < SymbolType > RightRG < SymbolType >::parse ( std::deque < sax::Token >
template < class SymbolType >
void RightRG < SymbolType >::parseRule ( std::deque < sax::Token >::iterator & input, RightRG & grammar ) {
SymbolType lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS < SymbolType > ( input );
- std::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs = GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS < SymbolType > ( input );
+ ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs = GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS < SymbolType > ( input );
grammar.addRule ( std::move ( lhs ), std::move ( rhs ) );
}
@@ -694,8 +694,8 @@ public:
* \returns true if the symbol is used, false othervise
*/
static bool used ( const grammar::RightRG < SymbolType > & grammar, const SymbolType & symbol ) {
- for ( const std::pair < const SymbolType, std::set < std::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & rule : grammar.getRules ( ) )
- for ( const std::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rhs : rule.second )
+ for ( const std::pair < const SymbolType, std::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & rule : grammar.getRules ( ) )
+ for ( const ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rhs : rule.second )
if ( ( rhs.template is < SymbolType > ( ) && ( rhs.template get < SymbolType > ( ) == symbol ) ) || ( rhs.template get < std::pair < SymbolType, SymbolType > > ( ).first == symbol ) )
return true;
@@ -742,11 +742,11 @@ public:
* \returns true if the symbol is used, false othervise
*/
static bool used ( const grammar::RightRG < SymbolType > & grammar, const SymbolType & symbol ) {
- for ( const std::pair < const SymbolType, std::set < std::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & rule : grammar.getRules ( ) ) {
+ for ( const std::pair < const SymbolType, std::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & rule : grammar.getRules ( ) ) {
if ( rule.first == symbol )
return true;
- for ( const std::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rhs : rule.second )
+ for ( const ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rhs : rule.second )
if ( rhs.template get < std::pair < SymbolType, SymbolType > > ( ).second == symbol )
return true;
diff --git a/alib2data/src/grammar/common/GrammarFromXMLParser.h b/alib2data/src/grammar/common/GrammarFromXMLParser.h
index 2be79243150633948881fadae71ad98fdf8cdac2..26de0d58243f5c5e1b690e67b0f5142838b6694a 100644
--- a/alib2data/src/grammar/common/GrammarFromXMLParser.h
+++ b/alib2data/src/grammar/common/GrammarFromXMLParser.h
@@ -60,7 +60,7 @@ public:
template < class SymbolType >
static std::vector<SymbolType> parseRuleRHS(std::deque<sax::Token>::iterator& input);
template < class SymbolType >
- static std::variant<SymbolType, std::pair<SymbolType, SymbolType>> parseRuleOneOrTwoSymbolsRHS(std::deque<sax::Token>::iterator& input);
+ static ext::variant<SymbolType, std::pair<SymbolType, SymbolType>> parseRuleOneOrTwoSymbolsRHS(std::deque<sax::Token>::iterator& input);
template<class T>
static void parseRules(std::deque<sax::Token>::iterator& input, T& grammar);
@@ -173,16 +173,16 @@ std::vector<SymbolType> GrammarFromXMLParser::parseRuleRHS(std::deque<sax::Token
}
template < class SymbolType >
-std::variant<SymbolType, std::pair<SymbolType, SymbolType>> GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS(std::deque<sax::Token>::iterator& input) {
+ext::variant<SymbolType, std::pair<SymbolType, SymbolType>> GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS(std::deque<sax::Token>::iterator& input) {
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "rhs");
SymbolType first = alib::xmlApi<SymbolType>::parse(input);
if(sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
SymbolType second = alib::xmlApi<SymbolType>::parse(input);
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "rhs");
- return std::variant<SymbolType, std::pair<SymbolType, SymbolType>>(std::make_pair(std::move(first), std::move(second)));
+ return ext::variant<SymbolType, std::pair<SymbolType, SymbolType>>(std::make_pair(std::move(first), std::move(second)));
} else {
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "rhs");
- return std::variant<SymbolType, std::pair<SymbolType, SymbolType>>(std::move(first));
+ return ext::variant<SymbolType, std::pair<SymbolType, SymbolType>>(std::move(first));
}
}
diff --git a/alib2data/src/grammar/common/GrammarNormalize.h b/alib2data/src/grammar/common/GrammarNormalize.h
index 0031f1fb50025160780133c448b7b79f745da7cf..cac417cb0749647c959b6a1ff1b47e4c52a36f35 100644
--- a/alib2data/src/grammar/common/GrammarNormalize.h
+++ b/alib2data/src/grammar/common/GrammarNormalize.h
@@ -26,16 +26,16 @@ public:
static std::pair < DefaultSymbolType, std::vector < DefaultSymbolType > > normalizeRHS ( std::pair < SymbolType, std::vector < SymbolType > > && symbol );
template < class SymbolType >
- static std::variant < DefaultSymbolType, std::pair < DefaultSymbolType, DefaultSymbolType > > normalizeRHS ( std::variant < SymbolType, std::pair < SymbolType, SymbolType > > && symbol );
+ static ext::variant < DefaultSymbolType, std::pair < DefaultSymbolType, DefaultSymbolType > > normalizeRHS ( ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > && symbol );
template < class SymbolType >
- static std::variant < std::vector < DefaultSymbolType >, std::pair < DefaultSymbolType, std::vector < DefaultSymbolType > > > normalizeRHS ( std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > && symbol );
+ static ext::variant < std::vector < DefaultSymbolType >, std::pair < DefaultSymbolType, std::vector < DefaultSymbolType > > > normalizeRHS ( ext::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > && symbol );
template < class SymbolType >
- static std::variant < std::vector < DefaultSymbolType >, std::pair < std::vector < DefaultSymbolType >, DefaultSymbolType > > normalizeRHS ( std::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > && symbol );
+ static ext::variant < std::vector < DefaultSymbolType >, std::pair < std::vector < DefaultSymbolType >, DefaultSymbolType > > normalizeRHS ( ext::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > && symbol );
template < class SymbolType >
- static std::variant < std::vector < DefaultSymbolType >, std::tuple < std::vector < DefaultSymbolType >, DefaultSymbolType, std::vector < DefaultSymbolType > > > normalizeRHS ( std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > && symbols );
+ static ext::variant < std::vector < DefaultSymbolType >, std::tuple < std::vector < DefaultSymbolType >, DefaultSymbolType, std::vector < DefaultSymbolType > > > normalizeRHS ( ext::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > && symbols );
};
@@ -45,39 +45,39 @@ std::pair < DefaultSymbolType, std::vector < DefaultSymbolType > > GrammarNormal
}
template < class SymbolType >
-std::variant < DefaultSymbolType, std::pair < DefaultSymbolType, DefaultSymbolType > > GrammarNormalize::normalizeRHS ( std::variant < SymbolType, std::pair < SymbolType, SymbolType > > && symbol ) {
+ext::variant < DefaultSymbolType, std::pair < DefaultSymbolType, DefaultSymbolType > > GrammarNormalize::normalizeRHS ( ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > && symbol ) {
if ( symbol.template is < SymbolType > ( ) ) {
- return std::variant < DefaultSymbolType, std::pair < DefaultSymbolType, DefaultSymbolType > > ( alphabet::SymbolNormalize::normalizeSymbol ( std::move ( symbol.template get < SymbolType > ( ) ) ) );
+ return ext::variant < DefaultSymbolType, std::pair < DefaultSymbolType, DefaultSymbolType > > ( alphabet::SymbolNormalize::normalizeSymbol ( std::move ( symbol.template get < SymbolType > ( ) ) ) );
} else {
std::pair < SymbolType, SymbolType > & inner = symbol.template get < std::pair < SymbolType, SymbolType > > ( );
- return std::variant < DefaultSymbolType, std::pair < DefaultSymbolType, DefaultSymbolType > > ( std::make_pair ( alphabet::SymbolNormalize::normalizeSymbol ( std::move ( inner.first ) ), alphabet::SymbolNormalize::normalizeSymbol ( std::move ( inner.second ) ) ) );
+ return ext::variant < DefaultSymbolType, std::pair < DefaultSymbolType, DefaultSymbolType > > ( std::make_pair ( alphabet::SymbolNormalize::normalizeSymbol ( std::move ( inner.first ) ), alphabet::SymbolNormalize::normalizeSymbol ( std::move ( inner.second ) ) ) );
}
}
template < class SymbolType >
-std::variant < std::vector < DefaultSymbolType >, std::pair < DefaultSymbolType, std::vector < DefaultSymbolType > > > GrammarNormalize::normalizeRHS ( std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > && symbol ) {
+ext::variant < std::vector < DefaultSymbolType >, std::pair < DefaultSymbolType, std::vector < DefaultSymbolType > > > GrammarNormalize::normalizeRHS ( ext::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > && symbol ) {
if ( symbol.template is < std::vector < SymbolType > > ( ) ) {
- return std::variant < std::vector < DefaultSymbolType >, std::pair < DefaultSymbolType, std::vector < DefaultSymbolType > > > ( alphabet::SymbolNormalize::normalizeSymbols ( std::move ( symbol.template get < std::vector < SymbolType > > ( ) ) ) );
+ return ext::variant < std::vector < DefaultSymbolType >, std::pair < DefaultSymbolType, std::vector < DefaultSymbolType > > > ( alphabet::SymbolNormalize::normalizeSymbols ( std::move ( symbol.template get < std::vector < SymbolType > > ( ) ) ) );
} else {
std::pair < SymbolType, std::vector < SymbolType > > & inner = symbol.template get < std::pair < SymbolType, std::vector < SymbolType > > > ( );
- return std::variant < std::vector < DefaultSymbolType >, std::pair < DefaultSymbolType, std::vector < DefaultSymbolType > > > ( std::make_pair ( alphabet::SymbolNormalize::normalizeSymbol ( std::move ( inner.first ) ), alphabet::SymbolNormalize::normalizeSymbols ( std::move ( inner.second ) ) ) );
+ return ext::variant < std::vector < DefaultSymbolType >, std::pair < DefaultSymbolType, std::vector < DefaultSymbolType > > > ( std::make_pair ( alphabet::SymbolNormalize::normalizeSymbol ( std::move ( inner.first ) ), alphabet::SymbolNormalize::normalizeSymbols ( std::move ( inner.second ) ) ) );
}
}
template < class SymbolType >
-std::variant < std::vector < DefaultSymbolType >, std::pair < std::vector < DefaultSymbolType >, DefaultSymbolType > > GrammarNormalize::normalizeRHS ( std::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > && symbol ) {
+ext::variant < std::vector < DefaultSymbolType >, std::pair < std::vector < DefaultSymbolType >, DefaultSymbolType > > GrammarNormalize::normalizeRHS ( ext::variant < std::vector < SymbolType >, std::pair < std::vector < SymbolType >, SymbolType > > && symbol ) {
if ( symbol.template is < std::vector < SymbolType > > ( ) ) {
- return std::variant < std::vector < DefaultSymbolType >, std::pair < std::vector < DefaultSymbolType >, DefaultSymbolType > > ( alphabet::SymbolNormalize::normalizeSymbols ( std::move ( symbol.template get < std::vector < SymbolType > > ( ) ) ) );
+ return ext::variant < std::vector < DefaultSymbolType >, std::pair < std::vector < DefaultSymbolType >, DefaultSymbolType > > ( alphabet::SymbolNormalize::normalizeSymbols ( std::move ( symbol.template get < std::vector < SymbolType > > ( ) ) ) );
} else {
std::pair < std::vector < SymbolType >, SymbolType > & inner = symbol.template get < std::pair < std::vector < SymbolType >, SymbolType > > ( );
- return std::variant < std::vector < DefaultSymbolType >, std::pair < std::vector < DefaultSymbolType >, DefaultSymbolType > > ( std::make_pair ( alphabet::SymbolNormalize::normalizeSymbols ( std::move ( inner.first ) ), alphabet::SymbolNormalize::normalizeSymbol ( std::move ( inner.second ) ) ) );
+ return ext::variant < std::vector < DefaultSymbolType >, std::pair < std::vector < DefaultSymbolType >, DefaultSymbolType > > ( std::make_pair ( alphabet::SymbolNormalize::normalizeSymbols ( std::move ( inner.first ) ), alphabet::SymbolNormalize::normalizeSymbol ( std::move ( inner.second ) ) ) );
}
}
template < class SymbolType >
-std::variant < std::vector < DefaultSymbolType >, std::tuple < std::vector < DefaultSymbolType >, DefaultSymbolType, std::vector < DefaultSymbolType > > > GrammarNormalize::normalizeRHS ( std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > && symbols ) {
+ext::variant < std::vector < DefaultSymbolType >, std::tuple < std::vector < DefaultSymbolType >, DefaultSymbolType, std::vector < DefaultSymbolType > > > GrammarNormalize::normalizeRHS ( ext::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > && symbols ) {
if ( symbols.template is < std::vector < SymbolType > > ( ) ) {
- return std::variant < std::vector < DefaultSymbolType >, std::tuple < std::vector < DefaultSymbolType >, DefaultSymbolType, std::vector < DefaultSymbolType > > > ( alphabet::SymbolNormalize::normalizeSymbols ( std::move ( symbols.template get < std::vector < SymbolType > > ( ) ) ) );
+ return ext::variant < std::vector < DefaultSymbolType >, std::tuple < std::vector < DefaultSymbolType >, DefaultSymbolType, std::vector < DefaultSymbolType > > > ( alphabet::SymbolNormalize::normalizeSymbols ( std::move ( symbols.template get < std::vector < SymbolType > > ( ) ) ) );
} else {
std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > & inner = symbols.template get < std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > ( );
@@ -85,7 +85,7 @@ std::variant < std::vector < DefaultSymbolType >, std::tuple < std::vector < Def
DefaultSymbolType second = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( std::get < 1 > ( inner ) ) );
std::vector < DefaultSymbolType > third = alphabet::SymbolNormalize::normalizeSymbols ( std::move ( std::get < 2 > ( inner ) ) );
- return std::variant < std::vector < DefaultSymbolType >, std::tuple < std::vector < DefaultSymbolType >, DefaultSymbolType, std::vector < DefaultSymbolType > > > ( std::make_tuple ( std::move ( first ), std::move ( second ), std::move ( third ) ) );
+ return ext::variant < std::vector < DefaultSymbolType >, std::tuple < std::vector < DefaultSymbolType >, DefaultSymbolType, std::vector < DefaultSymbolType > > > ( std::make_tuple ( std::move ( first ), std::move ( second ), std::move ( third ) ) );
}
}
diff --git a/alib2data/src/grammar/common/GrammarToXMLComposer.h b/alib2data/src/grammar/common/GrammarToXMLComposer.h
index 2b5f14830af8b44a69eebdee091312ce016c18b0..8ca48b3e89db74cd89ce2cd29033df35537a0be3 100644
--- a/alib2data/src/grammar/common/GrammarToXMLComposer.h
+++ b/alib2data/src/grammar/common/GrammarToXMLComposer.h
@@ -54,15 +54,15 @@ public:
template < class SymbolType >
static void composeRuleRHS(std::deque<sax::Token>& out, const std::vector<SymbolType>& symbols);
template < class SymbolType >
- static void composeRuleOneOrTwoSymbolsRHS(std::deque<sax::Token>& out, const std::variant<SymbolType, std::pair<SymbolType, SymbolType>>& symbols);
+ static void composeRuleOneOrTwoSymbolsRHS(std::deque<sax::Token>& out, const ext::variant<SymbolType, std::pair<SymbolType, SymbolType>>& symbols);
template < class SymbolType >
static void composeRuleGNFRHS(std::deque<sax::Token>& out, const std::pair<SymbolType, std::vector<SymbolType>>& symbols);
template < class SymbolType >
- static void composeRuleLeftLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<SymbolType>, std::pair<SymbolType, std::vector<SymbolType>>>& symbols);
+ static void composeRuleLeftLGRHS(std::deque<sax::Token>& out, const ext::variant<std::vector<SymbolType>, std::pair<SymbolType, std::vector<SymbolType>>>& symbols);
template < class SymbolType >
- static void composeRuleRightLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<SymbolType>, std::pair<std::vector<SymbolType>, SymbolType>>& symbols);
+ static void composeRuleRightLGRHS(std::deque<sax::Token>& out, const ext::variant<std::vector<SymbolType>, std::pair<std::vector<SymbolType>, SymbolType>>& symbols);
template < class SymbolType >
- static void composeRuleLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<SymbolType>, std::tuple<std::vector<SymbolType>, SymbolType, std::vector<SymbolType>>>& symbols);
+ static void composeRuleLGRHS(std::deque<sax::Token>& out, const ext::variant<std::vector<SymbolType>, std::tuple<std::vector<SymbolType>, SymbolType, std::vector<SymbolType>>>& symbols);
};
template < class SymbolType >
@@ -146,7 +146,7 @@ void GrammarToXMLComposer::composeRuleRHS(std::deque<sax::Token>& out, const std
}
template < class SymbolType >
-void GrammarToXMLComposer::composeRuleOneOrTwoSymbolsRHS(std::deque<sax::Token>& out, const std::variant<SymbolType, std::pair<SymbolType, SymbolType>>& symbols) {
+void GrammarToXMLComposer::composeRuleOneOrTwoSymbolsRHS(std::deque<sax::Token>& out, const ext::variant<SymbolType, std::pair<SymbolType, SymbolType>>& symbols) {
out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
if(symbols.template is<SymbolType>()) {
alib::xmlApi<SymbolType>::compose(out, symbols.template get<SymbolType>());
@@ -172,7 +172,7 @@ void GrammarToXMLComposer::composeRuleGNFRHS(std::deque<sax::Token>& out, const
}
template < class SymbolType >
-void GrammarToXMLComposer::composeRuleLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<SymbolType>, std::tuple<std::vector<SymbolType>, SymbolType, std::vector<SymbolType>>>& symbols) {
+void GrammarToXMLComposer::composeRuleLGRHS(std::deque<sax::Token>& out, const ext::variant<std::vector<SymbolType>, std::tuple<std::vector<SymbolType>, SymbolType, std::vector<SymbolType>>>& symbols) {
out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
if(symbols.template is<std::vector<SymbolType>>()) {
const std::vector<SymbolType>& rhs = symbols.template get<std::vector<SymbolType>>();
@@ -196,7 +196,7 @@ void GrammarToXMLComposer::composeRuleLGRHS(std::deque<sax::Token>& out, const s
}
template < class SymbolType >
-void GrammarToXMLComposer::composeRuleLeftLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<SymbolType>, std::pair<SymbolType, std::vector<SymbolType>>>& symbols) {
+void GrammarToXMLComposer::composeRuleLeftLGRHS(std::deque<sax::Token>& out, const ext::variant<std::vector<SymbolType>, std::pair<SymbolType, std::vector<SymbolType>>>& symbols) {
out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
if(symbols.template is<std::vector<SymbolType>>()) {
const std::vector<SymbolType>& rhs = symbols.template get<std::vector<SymbolType>>();
@@ -217,7 +217,7 @@ void GrammarToXMLComposer::composeRuleLeftLGRHS(std::deque<sax::Token>& out, con
}
template < class SymbolType >
-void GrammarToXMLComposer::composeRuleRightLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<SymbolType>, std::pair<std::vector<SymbolType>, SymbolType>>& symbols) {
+void GrammarToXMLComposer::composeRuleRightLGRHS(std::deque<sax::Token>& out, const ext::variant<std::vector<SymbolType>, std::pair<std::vector<SymbolType>, SymbolType>>& symbols) {
out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
if(symbols.template is<std::vector<SymbolType>>()) {
const std::vector<SymbolType>& rhs = symbols.template get<std::vector<SymbolType>>();
diff --git a/alib2data/src/indexes/common/IndexesNormalize.h b/alib2data/src/indexes/common/IndexesNormalize.h
index 87f8bf8dc3f7f379a18219843407b250b66167aa..d8a09df7cc7cb4fa2b2c4a8db6884127a607f1c6 100644
--- a/alib2data/src/indexes/common/IndexesNormalize.h
+++ b/alib2data/src/indexes/common/IndexesNormalize.h
@@ -38,7 +38,7 @@ public:
static std::trie < DefaultSymbolType, unsigned > normalizeTrie ( std::trie < SymbolType, unsigned > && trie );
template < class SymbolType >
- static std::trie < DefaultSymbolType, std::variant < void, unsigned > > normalizeTrie ( std::trie < SymbolType, std::variant < void, unsigned > > && trie );
+ static std::trie < DefaultSymbolType, ext::variant < void, unsigned > > normalizeTrie ( std::trie < SymbolType, ext::variant < void, unsigned > > && trie );
};
template < class SymbolType >
@@ -47,7 +47,7 @@ std::trie < DefaultSymbolType, unsigned > IndexesNormalize::normalizeTrie ( std:
}
template < class SymbolType >
-std::trie < DefaultSymbolType, std::variant < void, unsigned > > IndexesNormalize::normalizeTrie ( std::trie < SymbolType, std::variant < void, unsigned > > && trie ) {
+std::trie < DefaultSymbolType, ext::variant < void, unsigned > > IndexesNormalize::normalizeTrie ( std::trie < SymbolType, ext::variant < void, unsigned > > && trie ) {
return normalizeTrieInner ( std::move ( trie ) ) ;
}
diff --git a/alib2data/src/indexes/stringology/SuffixTrie.h b/alib2data/src/indexes/stringology/SuffixTrie.h
index c5bddedd4cb09f6708a32dc303743bfade5cc87f..84e9e2ac17a9d8e30e344b7c71ca90e3bc7f5a3b 100644
--- a/alib2data/src/indexes/stringology/SuffixTrie.h
+++ b/alib2data/src/indexes/stringology/SuffixTrie.h
@@ -51,7 +51,7 @@ class GeneralAlphabet;
template < class SymbolType = DefaultSymbolType >
class SuffixTrie final : public alib::ObjectBase, public alib::Components < SuffixTrie < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > {
protected:
- std::trie < SymbolType, std::variant < void, unsigned > > m_trie;
+ std::trie < SymbolType, ext::variant < void, unsigned > > m_trie;
public:
/**
@@ -65,15 +65,15 @@ public:
virtual ObjectBase * plunder ( ) &&;
explicit SuffixTrie ( std::set < SymbolType > edgeAlphabet );
- explicit SuffixTrie ( std::set < SymbolType > edgeAlphabet, std::trie < SymbolType, std::variant < void, unsigned > > trie );
- explicit SuffixTrie ( std::trie < SymbolType, std::variant < void, unsigned > > trie );
+ explicit SuffixTrie ( std::set < SymbolType > edgeAlphabet, std::trie < SymbolType, ext::variant < void, unsigned > > trie );
+ explicit SuffixTrie ( std::trie < SymbolType, ext::variant < void, unsigned > > trie );
- void checkTrie ( const std::trie < SymbolType, std::variant < void, unsigned > > & trie );
+ void checkTrie ( const std::trie < SymbolType, ext::variant < void, unsigned > > & trie );
/**
* @return Root node of the trie
*/
- const std::trie < SymbolType, std::variant < void, unsigned > > & getRoot ( ) const;
+ const std::trie < SymbolType, ext::variant < void, unsigned > > & getRoot ( ) const;
const std::set < SymbolType > & getAlphabet ( ) const {
return this->template accessComponent < GeneralAlphabet > ( ).get ( );
@@ -83,7 +83,7 @@ public:
* Sets the root node of the regular expression tree
* @param tree root node to set
*/
- void setTree ( std::trie < SymbolType, std::variant < void, unsigned > > tree );
+ void setTree ( std::trie < SymbolType, ext::variant < void, unsigned > > tree );
/**
* Removes symbol from the alphabet of symbol available in the regular expression
@@ -129,7 +129,7 @@ public:
return this;
std::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( this->template accessComponent < GeneralAlphabet > ( ).get ( ) ) );
- std::trie < DefaultSymbolType, std::variant < void, unsigned > > trie = IndexesNormalize::normalizeTrie ( std::move ( m_trie ) );
+ std::trie < DefaultSymbolType, ext::variant < void, unsigned > > trie = IndexesNormalize::normalizeTrie ( std::move ( m_trie ) );
return new SuffixTrie < > ( std::move ( alphabet ), std::move ( trie ) );
}
@@ -144,16 +144,16 @@ namespace indexes {
namespace stringology {
template < class SymbolType >
-SuffixTrie < SymbolType >::SuffixTrie ( std::set < SymbolType > edgeAlphabet ) : SuffixTrie ( std::move ( edgeAlphabet ), std::trie < SymbolType, std::variant < void, unsigned > > ( std::variant < void, unsigned >::template from < void > ( ) ) ) {
+SuffixTrie < SymbolType >::SuffixTrie ( std::set < SymbolType > edgeAlphabet ) : SuffixTrie ( std::move ( edgeAlphabet ), std::trie < SymbolType, ext::variant < void, unsigned > > ( ext::variant < void, unsigned >::template from < void > ( ) ) ) {
}
template < class SymbolType >
-SuffixTrie < SymbolType >::SuffixTrie ( std::set < SymbolType > edgeAlphabet, std::trie < SymbolType, std::variant < void, unsigned > > trie ) : alib::Components < SuffixTrie, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( edgeAlphabet ) ), std::tuple < > ( ) ), m_trie ( std::move ( trie ) ) {
+SuffixTrie < SymbolType >::SuffixTrie ( std::set < SymbolType > edgeAlphabet, std::trie < SymbolType, ext::variant < void, unsigned > > trie ) : alib::Components < SuffixTrie, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( edgeAlphabet ) ), std::tuple < > ( ) ), m_trie ( std::move ( trie ) ) {
checkTrie ( this->m_trie );
}
template < class SymbolType >
-SuffixTrie < SymbolType >::SuffixTrie ( std::trie < SymbolType, std::variant < void, unsigned > > trie ) : SuffixTrie ( computeMinimalEdgeAlphabet ( trie ), trie ) {
+SuffixTrie < SymbolType >::SuffixTrie ( std::trie < SymbolType, ext::variant < void, unsigned > > trie ) : SuffixTrie ( computeMinimalEdgeAlphabet ( trie ), trie ) {
}
template < class SymbolType >
@@ -167,8 +167,8 @@ alib::ObjectBase * SuffixTrie < SymbolType >::plunder ( ) && {
}
template < class SymbolType >
-void SuffixTrie < SymbolType >::checkTrie ( const std::trie < SymbolType, std::variant < void, unsigned > > & trie ) {
- for ( const std::pair < const SymbolType, std::trie < SymbolType, std::variant < void, unsigned > > > & child : trie.getChildren ( ) ) {
+void SuffixTrie < SymbolType >::checkTrie ( const std::trie < SymbolType, ext::variant < void, unsigned > > & trie ) {
+ for ( const std::pair < const SymbolType, std::trie < SymbolType, ext::variant < void, unsigned > > > & child : trie.getChildren ( ) ) {
if ( ! getAlphabet ( ).count ( child.first ) )
throw exception::CommonException ( "Symbol " + ext::to_string ( child.first ) + "not in the alphabet." );
checkTrie ( child.second );
@@ -176,12 +176,12 @@ void SuffixTrie < SymbolType >::checkTrie ( const std::trie < SymbolType, std::v
}
template < class SymbolType >
-const std::trie < SymbolType, std::variant < void, unsigned > > & SuffixTrie < SymbolType >::getRoot ( ) const {
+const std::trie < SymbolType, ext::variant < void, unsigned > > & SuffixTrie < SymbolType >::getRoot ( ) const {
return m_trie;
}
template < class SymbolType >
-void SuffixTrie < SymbolType >::setTree ( std::trie < SymbolType, std::variant < void, unsigned > > trie ) {
+void SuffixTrie < SymbolType >::setTree ( std::trie < SymbolType, ext::variant < void, unsigned > > trie ) {
checkTrie ( trie );
this->m_trie = std::move ( trie ).plunder ( );
}
@@ -212,7 +212,7 @@ template < class SymbolType >
SuffixTrie < SymbolType > SuffixTrie < SymbolType >::parse ( std::deque < sax::Token >::iterator & input ) {
sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, SuffixTrie::getXmlTagName() );
std::set < SymbolType > edgeAlphabet = alib::xmlApi < std::set < SymbolType > >::parse ( input );
- std::trie < SymbolType, std::variant < void, unsigned > > root = alib::xmlApi < std::trie < SymbolType, std::variant < void, unsigned > > >::parse ( input );
+ std::trie < SymbolType, ext::variant < void, unsigned > > root = alib::xmlApi < std::trie < SymbolType, ext::variant < void, unsigned > > >::parse ( input );
SuffixTrie < SymbolType > trie ( std::move ( edgeAlphabet ), std::move ( root ) );
sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, SuffixTrie::getXmlTagName() );
@@ -223,7 +223,7 @@ template < class SymbolType >
void SuffixTrie < SymbolType >::compose ( std::deque < sax::Token > & out ) const {
out.emplace_back ( SuffixTrie::getXmlTagName(), sax::Token::TokenType::START_ELEMENT );
alib::xmlApi < std::set < SymbolType > >::compose ( out, getAlphabet ( ) );
- alib::xmlApi < std::trie < SymbolType, std::variant < void, unsigned > > >::compose ( out, getRoot ( ) );
+ alib::xmlApi < std::trie < SymbolType, ext::variant < void, unsigned > > >::compose ( out, getRoot ( ) );
out.emplace_back ( SuffixTrie::getXmlTagName(), sax::Token::TokenType::END_ELEMENT );
}
@@ -241,8 +241,8 @@ namespace alib {
template < class SymbolType >
class ComponentConstraint < indexes::stringology::SuffixTrie < SymbolType >, SymbolType, indexes::stringology::GeneralAlphabet > {
- static bool used ( const std::trie < SymbolType, std::variant < void, unsigned > > & trie, const SymbolType & symbol ) {
- for ( const std::pair < const SymbolType, std::trie < SymbolType, std::variant < void, unsigned > > > & child : trie.getChildren ( ) ) {
+ static bool used ( const std::trie < SymbolType, ext::variant < void, unsigned > > & trie, const SymbolType & symbol ) {
+ for ( const std::pair < const SymbolType, std::trie < SymbolType, ext::variant < void, unsigned > > > & child : trie.getChildren ( ) ) {
if ( symbol == child.first || checkTrie ( trie, child.second ) )
return true;
}
diff --git a/alib2data/test-src/string/StringTest.cpp b/alib2data/test-src/string/StringTest.cpp
index d869e1776f129e113c31fd91ce544c8934a9e263..033e4e8c75e13f62cc60500e3a13dcb4c12f23c0 100644
--- a/alib2data/test-src/string/StringTest.cpp
+++ b/alib2data/test-src/string/StringTest.cpp
@@ -74,21 +74,21 @@ void StringTest::testXMLParser ( ) {
}
void StringTest::testStringInMap ( ) {
- std::map < std::variant < string::Epsilon < >, int >, int > testMap;
- std::variant < string::Epsilon < >, int > epsVar {
+ std::map < ext::variant < string::Epsilon < >, int >, int > testMap;
+ ext::variant < string::Epsilon < >, int > epsVar {
string::Epsilon < > { }
};
CPPUNIT_ASSERT ( string::Epsilon < >::EPSILON == epsVar.get < string::Epsilon < > > ( ) );
CPPUNIT_ASSERT ( epsVar.get < string::Epsilon < > > ( ) == string::Epsilon < >::EPSILON );
- std::pair < std::variant < string::Epsilon < >, int >, int > epsVarPair = std::make_pair ( epsVar, 10 );
+ std::pair < ext::variant < string::Epsilon < >, int >, int > epsVarPair = std::make_pair ( epsVar, 10 );
CPPUNIT_ASSERT ( string::Epsilon < >::EPSILON == epsVarPair.first.get < string::Epsilon < > > ( ) );
CPPUNIT_ASSERT ( epsVarPair.first.get < string::Epsilon < > > ( ) == string::Epsilon < >::EPSILON );
- testMap.insert ( std::make_pair ( std::variant < string::Epsilon < >, int > { string::Epsilon < > { }
+ testMap.insert ( std::make_pair ( ext::variant < string::Epsilon < >, int > { string::Epsilon < > { }
}, 10 ) );
- CPPUNIT_ASSERT ( testMap.find ( std::variant < string::Epsilon < >, int > { string::Epsilon < > { }
+ CPPUNIT_ASSERT ( testMap.find ( ext::variant < string::Epsilon < >, int > { string::Epsilon < > { }
} ) != testMap.end ( ) );
for ( const auto & entry : testMap ) {
diff --git a/alib2data_experimental/src/grammar/parsing/LRParserTypes.h b/alib2data_experimental/src/grammar/parsing/LRParserTypes.h
index b73cedaf0735a5cf306a6f958123c48ad270c63e..8737ed352c76b4e27a623db4c37550ab9571e82a 100644
--- a/alib2data_experimental/src/grammar/parsing/LRParserTypes.h
+++ b/alib2data_experimental/src/grammar/parsing/LRParserTypes.h
@@ -27,7 +27,7 @@ enum class LRAction {
};
typedef std::map < DefaultSymbolType, std::set < std::pair < unsigned, std::vector < DefaultSymbolType > > > > LR0Items;
-typedef std::map < std::pair < DefaultStateType, DefaultSymbolType >, std::pair < LRAction, std::variant < DefaultStateType, std::pair < DefaultSymbolType, std::vector < DefaultSymbolType > > > > > LRActionTable;
+typedef std::map < std::pair < DefaultStateType, DefaultSymbolType >, std::pair < LRAction, ext::variant < DefaultStateType, std::pair < DefaultSymbolType, std::vector < DefaultSymbolType > > > > > LRActionTable;
typedef std::map < std::pair < DefaultStateType, DefaultSymbolType >, DefaultStateType > LRGotoTable;
} /* namespace parsing */
diff --git a/alib2std/src/extensions/utility.hpp b/alib2std/src/extensions/utility.hpp
index 768caf76820a3337ac06794bd2f595771e18bc30..f24cfbbcd99e47380bb7a4aeeacc15d3f6feaddd 100644
--- a/alib2std/src/extensions/utility.hpp
+++ b/alib2std/src/extensions/utility.hpp
@@ -10,6 +10,31 @@
#include <utility>
#include "type_traits.hpp"
+#include <cstddef>
+
+namespace ext {
+
+template<class T>
+struct SizeOf {
+ static const size_t size = sizeof(T);
+};
+
+template<>
+struct SizeOf<void> {
+ static const size_t size = 1;
+};
+
+template<class T>
+struct AlignOf {
+ static const size_t align = alignof(T);
+};
+
+template<>
+struct AlignOf<void> {
+ static const size_t align = 1;
+};
+
+} /* namespace ext */
namespace std {
diff --git a/alib2std/src/extensions/variant.hpp b/alib2std/src/extensions/variant.hpp
index 99a947954c6c8d2847f457fbf754dacc91231ff7..013eac0d546a852f5ef5a9ae43f124e3610c4aad 100644
--- a/alib2std/src/extensions/variant.hpp
+++ b/alib2std/src/extensions/variant.hpp
@@ -19,9 +19,10 @@
#include <sstream>
#include "compare.hpp"
+#include "utility.hpp"
#include "type_traits.hpp"
-namespace std {
+namespace ext {
template <size_t arg1, size_t ... others>
struct static_max;
@@ -211,26 +212,6 @@ public:
variant_base() : variant_base<ST, AT, Ts...>::variant_base ( type_id_hash_code ( typeid(void).hash_code() ) ) { }
};
-template<class T>
-struct SizeOf {
- static const size_t size = sizeof(T);
-};
-
-template<>
-struct SizeOf<void> {
- static const size_t size = 1;
-};
-
-template<class T>
-struct AlignOf {
- static const size_t align = alignof(T);
-};
-
-template<>
-struct AlignOf<void> {
- static const size_t align = 1;
-};
-
template<typename ... Ts>
class variant : public variant_base<static_max<SizeOf<Ts>::size...>, static_max<AlignOf<Ts>::align...>, Ts...> {
using helper_t = variant_helper<Ts...>;
@@ -363,19 +344,15 @@ public:
}
};
-} /* namespace std */
-
-namespace ext {
-
template<typename ... Ts>
-struct compare<std::variant<Ts...>> {
- int operator()(const std::variant<Ts...>& first, const std::variant<Ts...>& second) const {
+struct compare<ext::variant<Ts...>> {
+ int operator()(const ext::variant<Ts...>& first, const ext::variant<Ts...>& second) const {
return first.compare(second);
}
};
template < class ... Ts >
-std::string to_string ( const std::variant < Ts ... > & value ) {
+std::string to_string ( const ext::variant < Ts ... > & value ) {
std::stringstream ss;
ss << value;
return ss.str();
diff --git a/alib2std/test-src/extensions/VariantTest.cpp b/alib2std/test-src/extensions/VariantTest.cpp
index 57a08e5d6d60aa22153a97065f19b46de6c293b9..16f3f56e6286887b803b8322de60721b11b85ed3 100644
--- a/alib2std/test-src/extensions/VariantTest.cpp
+++ b/alib2std/test-src/extensions/VariantTest.cpp
@@ -13,7 +13,7 @@ void VariantTest::tearDown() {
}
void VariantTest::testVariant() {
- std::variant<int, std::string, VariantTest::test> d(10);
+ ext::variant<int, std::string, VariantTest::test> d(10);
CPPUNIT_ASSERT( d.is<int>() );
CPPUNIT_ASSERT( d.get<int>() == 10 );
@@ -30,7 +30,7 @@ void VariantTest::testVariant() {
CPPUNIT_ASSERT( d.is<VariantTest::test>() );
CPPUNIT_ASSERT( d.get<VariantTest::test>() == tmp );
- std::variant<int, std::string, VariantTest::test> e(d);
+ ext::variant<int, std::string, VariantTest::test> e(d);
CPPUNIT_ASSERT( e.get<VariantTest::test>() == tmp );
*(e.get<VariantTest::test>().holder) = 43;
@@ -47,7 +47,7 @@ void VariantTest::testVariant() {
CPPUNIT_ASSERT( (e == d) == false );
- d = std::variant<int, std::string, VariantTest::test>(0);
+ d = ext::variant<int, std::string, VariantTest::test>(0);
d = e;
CPPUNIT_ASSERT( *(d.get<VariantTest::test>().holder) == 43 );
@@ -64,15 +64,15 @@ void VariantTest::testVariantSet() {
std::string str = "abcde";
- std::variant<int, std::string, VariantTest::test> d(VariantTest::test {});
+ ext::variant<int, std::string, VariantTest::test> d(VariantTest::test {});
*(d.get<VariantTest::test>().holder) = 42;
- std::variant<int, std::string, VariantTest::test> e(d);
+ ext::variant<int, std::string, VariantTest::test> e(d);
- std::variant<int, std::string, VariantTest::test> f(5);
+ ext::variant<int, std::string, VariantTest::test> f(5);
- std::variant<int, std::string, VariantTest::test> g(str);
+ ext::variant<int, std::string, VariantTest::test> g(str);
- std::set<std::variant<int, std::string, VariantTest::test>> testSet;
+ std::set<ext::variant<int, std::string, VariantTest::test>> testSet;
testSet.insert(d);
testSet.insert(e);
testSet.insert(f);
@@ -80,7 +80,7 @@ void VariantTest::testVariantSet() {
CPPUNIT_ASSERT( testSet.size() == 3 );
- for(std::set<std::variant<int, std::string, VariantTest::test>>::const_iterator iter = testSet.begin(); iter != testSet.end(); iter++) {
+ for(std::set<ext::variant<int, std::string, VariantTest::test>>::const_iterator iter = testSet.begin(); iter != testSet.end(); iter++) {
if(iter->is<int>())
CPPUNIT_ASSERT( iter->get<int>() == 5);
if(iter->is<std::string>())
@@ -89,25 +89,25 @@ void VariantTest::testVariantSet() {
CPPUNIT_ASSERT( iter->get<VariantTest::test>() == tmp );
}
- std::variant<VariantTest::test2, std::string, VariantTest::test> h("aa");
+ ext::variant<VariantTest::test2, std::string, VariantTest::test> h("aa");
CPPUNIT_ASSERT( h.is<std::string>() );
- std::map<std::variant<std::string, int>, int> testMap;
- testMap.insert(std::make_pair(std::variant<std::string, int> {"aa"}, 10));
+ std::map<ext::variant<std::string, int>, int> testMap;
+ testMap.insert(std::make_pair(ext::variant<std::string, int> {"aa"}, 10));
CPPUNIT_ASSERT( testMap.size() == 1 );
- CPPUNIT_ASSERT( testMap.find(std::variant<std::string, int> {"aa"}) != testMap.end() );
- CPPUNIT_ASSERT( testMap.find(std::variant<std::string, int> {10}) == testMap.end() );
+ CPPUNIT_ASSERT( testMap.find(ext::variant<std::string, int> {"aa"}) != testMap.end() );
+ CPPUNIT_ASSERT( testMap.find(ext::variant<std::string, int> {10}) == testMap.end() );
- testMap.insert(std::make_pair(std::variant<std::string, int> {"ab"}, 11));
- testMap.insert(std::make_pair(std::variant<std::string, int> {3}, 13));
+ testMap.insert(std::make_pair(ext::variant<std::string, int> {"ab"}, 11));
+ testMap.insert(std::make_pair(ext::variant<std::string, int> {3}, 13));
- CPPUNIT_ASSERT( testMap.find(std::variant<std::string, int> {"aa"}) != testMap.end() );
- CPPUNIT_ASSERT( testMap.find(std::variant<std::string, int> {10}) == testMap.end() );
+ CPPUNIT_ASSERT( testMap.find(ext::variant<std::string, int> {"aa"}) != testMap.end() );
+ CPPUNIT_ASSERT( testMap.find(ext::variant<std::string, int> {10}) == testMap.end() );
}
void VariantTest::testVariantSet2() {
- std::set<std::variant<std::string, int>> s, t, u;
+ std::set<ext::variant<std::string, int>> s, t, u;
s.insert(std::string { "aa" } );
s.insert(123);
@@ -117,8 +117,8 @@ void VariantTest::testVariantSet2() {
}
void VariantTest::testVariantVoid() {
- std::variant<void, int> i(1);
- std::variant<void, int> v;
+ ext::variant<void, int> i(1);
+ ext::variant<void, int> v;
CPPUNIT_ASSERT ( v.is < void > ( ) );
CPPUNIT_ASSERT ( i.is < int > ( ) );
@@ -126,7 +126,7 @@ void VariantTest::testVariantVoid() {
i.set();
CPPUNIT_ASSERT ( i.is < void > ( ) );
- std::variant<void, int> copy = i;
+ ext::variant<void, int> copy = i;
CPPUNIT_ASSERT ( copy == v );
@@ -134,26 +134,26 @@ void VariantTest::testVariantVoid() {
CPPUNIT_ASSERT ( v.get<int>() == 10 );
- std::variant<int, void> v2;
+ ext::variant<int, void> v2;
CPPUNIT_ASSERT ( v2.is < void > ( ) );
}
void VariantTest::testVariantDefault() {
- std::variant<int, std::string, void> v1 = std::variant<int, std::string, void>::from<std::string>();
+ ext::variant<int, std::string, void> v1 = ext::variant<int, std::string, void>::from<std::string>();
CPPUNIT_ASSERT ( v1.get<std::string>() == "");
- std::variant<int, std::string, void> v2 = std::variant<int, std::string, void>::from<void>();
+ ext::variant<int, std::string, void> v2 = ext::variant<int, std::string, void>::from<void>();
CPPUNIT_ASSERT ( v2.is<void> ( ) );
- std::variant<int, std::string, void> v3 = std::variant<int, std::string, void>::from<int>();
+ ext::variant<int, std::string, void> v3 = ext::variant<int, std::string, void>::from<int>();
CPPUNIT_ASSERT ( v3.get<int> ( ) == 0 );
}
void VariantTest::testVariantSameTypes() {
- std::variant < int, int, char > v1 ( 1 );
+ ext::variant < int, int, char > v1 ( 1 );
CPPUNIT_ASSERT ( v1.get < int > ( ) == 1 );
@@ -167,9 +167,9 @@ void VariantTest::testVariantSameTypes() {
}
void VariantTest::testSizeT() {
- std::variant < size_t, int, void > a ( ( size_t ) 1 );
- std::variant < size_t, int, void > b ( 1 );
- std::variant < size_t, int, void > c;
+ ext::variant < size_t, int, void > a ( ( size_t ) 1 );
+ ext::variant < size_t, int, void > b ( 1 );
+ ext::variant < size_t, int, void > c;
CPPUNIT_ASSERT ( a.is < size_t > ( ) );
CPPUNIT_ASSERT ( b.is < int > ( ) );
@@ -177,6 +177,6 @@ void VariantTest::testSizeT() {
}
void VariantTest::testMoveSemantics() {
- CPPUNIT_ASSERT ( ( std::is_nothrow_move_constructible < std::variant < void, int, size_t > >::value ) );
- CPPUNIT_ASSERT ( ( std::is_move_constructible < std::variant < void, int, size_t > >::value && std::is_move_assignable < std::variant < void, int, size_t > >::value ) );
+ CPPUNIT_ASSERT ( ( std::is_nothrow_move_constructible < ext::variant < void, int, size_t > >::value ) );
+ CPPUNIT_ASSERT ( ( std::is_move_constructible < ext::variant < void, int, size_t > >::value && std::is_move_assignable < ext::variant < void, int, size_t > >::value ) );
}
diff --git a/alib2str/src/automaton/AutomatonFromStringParser.cpp b/alib2str/src/automaton/AutomatonFromStringParser.cpp
index 1682f4ef79732edbf348d55bf06e75daa41ff527..bf58ef54de860828a7307e76a7a13aa7bfe704b7 100644
--- a/alib2str/src/automaton/AutomatonFromStringParser.cpp
+++ b/alib2str/src/automaton/AutomatonFromStringParser.cpp
@@ -58,7 +58,7 @@ EpsilonNFA < > AutomatonFromStringParser::parseEpsilonNFA(std::istream& input) {
if(token.type != AutomatonFromStringLexer::TokenType::EPSILON_NFA) {
throw exception::CommonException("Unrecognised ENFA token.");
}
- std::vector<std::variant<DefaultEpsilonType, DefaultSymbolType> > symbols;
+ std::vector<ext::variant<DefaultEpsilonType, DefaultSymbolType> > symbols;
token = AutomatonFromStringLexer::next(input);
while(token.type != AutomatonFromStringLexer::TokenType::NEW_LINE) {
@@ -66,10 +66,10 @@ EpsilonNFA < > AutomatonFromStringParser::parseEpsilonNFA(std::istream& input) {
AutomatonFromStringLexer::putback(input, token);
DefaultSymbolType symbol = alib::stringApi<DefaultSymbolType>::parse(input);
- std::variant<DefaultEpsilonType, DefaultSymbolType> symbolVariant(symbol);
+ ext::variant<DefaultEpsilonType, DefaultSymbolType> symbolVariant(symbol);
symbols.push_back(symbolVariant);
} else if(token.type == AutomatonFromStringLexer::TokenType::EPSILON) {
- symbols.push_back(std::variant<DefaultEpsilonType, DefaultSymbolType>::from < DefaultEpsilonType > ( ));
+ symbols.push_back(ext::variant<DefaultEpsilonType, DefaultSymbolType>::from < DefaultEpsilonType > ( ));
}
token = AutomatonFromStringLexer::next(input);
@@ -78,7 +78,7 @@ EpsilonNFA < > AutomatonFromStringParser::parseEpsilonNFA(std::istream& input) {
DefaultStateType* initialState = NULL;
std::set<DefaultStateType> finalStates;
std::set<DefaultStateType> states;
- std::set<std::tuple<DefaultStateType, std::variant<DefaultEpsilonType, DefaultSymbolType>, DefaultStateType>> transitionFunction;
+ std::set<std::tuple<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>, DefaultStateType>> transitionFunction;
parseEpsilonNFATransition(input, states, symbols, initialState, finalStates, transitionFunction);
token = AutomatonFromStringLexer::next(input);
@@ -99,13 +99,13 @@ EpsilonNFA < > AutomatonFromStringParser::parseEpsilonNFA(std::istream& input) {
EpsilonNFA < > res(*initialState);
delete initialState;
- for(const std::variant<DefaultEpsilonType, DefaultSymbolType> inputSymbol : symbols) {
+ for(const ext::variant<DefaultEpsilonType, DefaultSymbolType> inputSymbol : symbols) {
if(inputSymbol.is<DefaultSymbolType>())
res.addInputSymbol(inputSymbol.get<DefaultSymbolType>());
}
res.setStates(states);
res.setFinalStates(finalStates);
- for(const std::tuple<DefaultStateType, std::variant<DefaultEpsilonType, DefaultSymbolType>, DefaultStateType> transition : transitionFunction) {
+ for(const std::tuple<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>, DefaultStateType> transition : transitionFunction) {
res.addTransition(std::get<0>(transition), std::get<1>(transition), std::get<2>(transition));
}
@@ -277,7 +277,7 @@ void AutomatonFromStringParser::initialFinalState(std::istream& input, bool& ini
}
-void AutomatonFromStringParser::parseEpsilonNFATransition(std::istream& input, std::set<DefaultStateType>& states, const std::vector<std::variant<DefaultEpsilonType, DefaultSymbolType>>& symbols, DefaultStateType*& initialState, std::set<DefaultStateType>& finalStates, std::set<std::tuple<DefaultStateType, std::variant<DefaultEpsilonType, DefaultSymbolType>, DefaultStateType>>& transitionFunction) {
+void AutomatonFromStringParser::parseEpsilonNFATransition(std::istream& input, std::set<DefaultStateType>& states, const std::vector<ext::variant<DefaultEpsilonType, DefaultSymbolType>>& symbols, DefaultStateType*& initialState, std::set<DefaultStateType>& finalStates, std::set<std::tuple<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>, DefaultStateType>>& transitionFunction) {
bool initial = false;
bool final = false;
@@ -292,7 +292,7 @@ void AutomatonFromStringParser::parseEpsilonNFATransition(std::istream& input, s
if(final) finalStates.insert(from);
AutomatonFromStringLexer::Token token = AutomatonFromStringLexer::next(input);
- std::vector<std::variant<DefaultEpsilonType, DefaultSymbolType>>::const_iterator iter = symbols.begin();
+ std::vector<ext::variant<DefaultEpsilonType, DefaultSymbolType>>::const_iterator iter = symbols.begin();
while(token.type != AutomatonFromStringLexer::TokenType::NEW_LINE) {
if(iter == symbols.end()) throw exception::CommonException("Invalid line format");
diff --git a/alib2str/src/automaton/AutomatonFromStringParser.h b/alib2str/src/automaton/AutomatonFromStringParser.h
index eb3a23ad5ba1e4b4bcafd0223e1b091375e03c0a..27492d2cda0522298d57a0cc6905e46d0af4cd51 100644
--- a/alib2str/src/automaton/AutomatonFromStringParser.h
+++ b/alib2str/src/automaton/AutomatonFromStringParser.h
@@ -25,7 +25,7 @@ namespace automaton {
class AutomatonFromStringParser {
static void initialFinalState(std::istream& input, bool& initial, bool& final);
- static void parseEpsilonNFATransition(std::istream& input, std::set<DefaultStateType>& states, const std::vector<std::variant<DefaultEpsilonType, DefaultSymbolType>>& symbols, DefaultStateType*& initialState, std::set<DefaultStateType>& finalStates, std::set<std::tuple<DefaultStateType, std::variant<DefaultEpsilonType, DefaultSymbolType>, DefaultStateType>>& transitionFunction);
+ static void parseEpsilonNFATransition(std::istream& input, std::set<DefaultStateType>& states, const std::vector<ext::variant<DefaultEpsilonType, DefaultSymbolType>>& symbols, DefaultStateType*& initialState, std::set<DefaultStateType>& finalStates, std::set<std::tuple<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>, DefaultStateType>>& transitionFunction);
static void parseMultiInitialStateNFATransition(std::istream& input, MultiInitialStateNFA < DefaultSymbolType, DefaultStateType > & res, const std::vector<DefaultSymbolType>& symbols);
static void parseNFATransition(std::istream& input, std::set<DefaultStateType>& states, const std::vector<DefaultSymbolType>& symbols, DefaultStateType*& initialState, std::set<DefaultStateType>& finalStates, std::set<std::tuple<DefaultStateType, DefaultSymbolType, DefaultStateType>>& transitionFunction);
static void parseDFATransition(std::istream& input, std::set<DefaultStateType>& states, const std::vector<DefaultSymbolType>& symbols, DefaultStateType*& initialState, std::set<DefaultStateType>& finalStates, std::set<std::tuple<DefaultStateType, DefaultSymbolType, DefaultStateType>>& transitionFunction);