diff --git a/aaccess2/src/PairSetAccess.cpp b/aaccess2/src/PairSetAccess.cpp
index 55d7e55917560e295c7f4e4be854a291266bcab9..21bc28a46e6bbc870c456a17aecef514ccce83c9 100644
--- a/aaccess2/src/PairSetAccess.cpp
+++ b/aaccess2/src/PairSetAccess.cpp
@@ -16,10 +16,10 @@
#include <container/ObjectsPair.h>
#include <container/ObjectsTree.h>
-void PairSetAccess::access ( const ext::set < std::pair < alib::Object, alib::Object > > & pairSet, const PairSetSettings::Settings & settings, const OperationSettings::Settings & operation ) {
+void PairSetAccess::access ( const ext::set < ext::pair < alib::Object, alib::Object > > & pairSet, const PairSetSettings::Settings & settings, const OperationSettings::Settings & operation ) {
if ( settings == PairSetSettings::Settings::FIRST && operation == OperationSettings::Settings::GET ) {
ext::set < alib::Object > res;
- for ( const std::pair < alib::Object, alib::Object > & pair : pairSet )
+ for ( const ext::pair < alib::Object, alib::Object > & pair : pairSet )
res.insert ( pair.first );
return alib::XmlDataFactory::toStdout ( res );
@@ -27,7 +27,7 @@ void PairSetAccess::access ( const ext::set < std::pair < alib::Object, alib::Ob
if ( settings == PairSetSettings::Settings::SECOND && operation == OperationSettings::Settings::GET ) {
ext::set < alib::Object > res;
- for ( const std::pair < alib::Object, alib::Object > & pair : pairSet )
+ for ( const ext::pair < alib::Object, alib::Object > & pair : pairSet )
res.insert ( pair.second );
return alib::XmlDataFactory::toStdout ( res );
diff --git a/aaccess2/src/PairSetAccess.h b/aaccess2/src/PairSetAccess.h
index 1989d71cc602cbb3bff2302f9c5d112f98099fe8..1821ee60390b068a90fc9226dfc8aba3b0a4413e 100644
--- a/aaccess2/src/PairSetAccess.h
+++ b/aaccess2/src/PairSetAccess.h
@@ -19,7 +19,7 @@
class PairSetAccess {
public:
- static void access ( const ext::set < std::pair < alib::Object, alib::Object > > & pairSet, const PairSetSettings::Settings & settings, const OperationSettings::Settings & operation );
+ static void access ( const ext::set < ext::pair < alib::Object, alib::Object > > & pairSet, const PairSetSettings::Settings & settings, const OperationSettings::Settings & operation );
};
diff --git a/aaccess2/src/aaccess.cpp b/aaccess2/src/aaccess.cpp
index 4804654928724186067139d358b36191ca06e431..b29764279ce41839e8d045f65ca7db9f0eb52dbf 100644
--- a/aaccess2/src/aaccess.cpp
+++ b/aaccess2/src/aaccess.cpp
@@ -194,8 +194,8 @@ int main ( int argc, char * argv[] ) {
measurements::start ( "Accesss print", measurements::Type::MAIN );
TreeAccess::access ( tree, TreeSettings::fromString ( treeInput.getValue ( ) ), OperationSettings::fromString ( operation.getValue ( ) ), argumentTokens );
- } else if ( alib::XmlDataFactory::first < ext::set < std::pair < alib::Object, alib::Object > > > ( tokens ) && pairSetInput.isSet ( ) ) {
- ext::set < std::pair < alib::Object, alib::Object > > pairSet = alib::XmlDataFactory::fromTokens ( std::move ( tokens ) );
+ } else if ( alib::XmlDataFactory::first < ext::set < ext::pair < alib::Object, alib::Object > > > ( tokens ) && pairSetInput.isSet ( ) ) {
+ ext::set < ext::pair < alib::Object, alib::Object > > pairSet = alib::XmlDataFactory::fromTokens ( std::move ( tokens ) );
measurements::end ( );
measurements::start ( "Accesss print", measurements::Type::MAIN );
diff --git a/aintrospection2/src/aintrospection.cpp b/aintrospection2/src/aintrospection.cpp
index 6b791b4f1d4fe6f042a63b81c383b050887dd5a1..bce717a5c343f2332199be2aa7af957e19f43117 100644
--- a/aintrospection2/src/aintrospection.cpp
+++ b/aintrospection2/src/aintrospection.cpp
@@ -81,7 +81,7 @@ int main ( int argc, char * argv[] ) {
if ( algorithmInterfaceIter == introspection::Algorithms::getAlgorithmInterfaces ( ).end ( ) )
std::cout << "No such algorithm as " << algorithmInterface.getValue ( ) << std::endl;
else
- std::cout << * algorithmInterfaceIter << std::endl;
+ std::cout << algorithmInterfaceIter->first << "->" << algorithmInterfaceIter->second << std::endl;
} else if ( algorithmCallbacks.isSet ( ) ) {
auto algorithmCallbacksIter = introspection::Algorithms::getAlgorithmCallbacks ( ).find ( algorithmCallbacks.getValue ( ) );
diff --git a/alib2algo/src/automaton/convert/ToGrammarLeftRG.cpp b/alib2algo/src/automaton/convert/ToGrammarLeftRG.cpp
index 0a58e3c20a9cff3e3f94f10186f1fe09ed57863a..4c4d1d1d00c07e32160e40e74dba62de4a765486 100644
--- a/alib2algo/src/automaton/convert/ToGrammarLeftRG.cpp
+++ b/alib2algo/src/automaton/convert/ToGrammarLeftRG.cpp
@@ -43,10 +43,10 @@ grammar::LeftRG < > ToGrammarLeftRG::convert(const automaton::NFA < > & automato
for(const auto& to : transition.second)
{
// 3a
- grammar.addRule(nonterminalMap.find(to)->second, std::make_pair(nonterminalMap.find(from)->second, input));
+ grammar.addRule(nonterminalMap.find(to)->second, ext::make_pair(nonterminalMap.find(from)->second, input));
if(automaton.getFinalStates().count(to) > 0)
- grammar.addRule(grammar.getInitialSymbol(), std::make_pair(nonterminalMap.find(from)->second, input));
+ grammar.addRule(grammar.getInitialSymbol(), ext::make_pair(nonterminalMap.find(from)->second, input));
if(automaton.getInitialState() == from)
@@ -89,10 +89,10 @@ grammar::LeftRG < > ToGrammarLeftRG::convert(const automaton::DFA<>& automaton)
const DefaultStateType& to = transition.second;
// 3a
- grammar.addRule(nonterminalMap.find(to)->second, std::make_pair(nonterminalMap.find(from)->second, input));
+ grammar.addRule(nonterminalMap.find(to)->second, ext::make_pair(nonterminalMap.find(from)->second, input));
if(automaton.getFinalStates().count(to) > 0)
- grammar.addRule(grammar.getInitialSymbol(), std::make_pair(nonterminalMap.find(from)->second, input));
+ grammar.addRule(grammar.getInitialSymbol(), ext::make_pair(nonterminalMap.find(from)->second, input));
if(automaton.getInitialState() == from)
diff --git a/alib2algo/src/automaton/convert/ToGrammarRightRG.cpp b/alib2algo/src/automaton/convert/ToGrammarRightRG.cpp
index 3419ad39383de28d2720014e7dbad72148496dcf..0c17f756b8f1804b1cc94c9c4d8ff7fcedb3706e 100644
--- a/alib2algo/src/automaton/convert/ToGrammarRightRG.cpp
+++ b/alib2algo/src/automaton/convert/ToGrammarRightRG.cpp
@@ -42,7 +42,7 @@ grammar::RightRG < > ToGrammarRightRG::convert(const automaton::NFA < > & automa
const DefaultStateType& from = transition.first.first;
const DefaultSymbolType& input = transition.first.second;
for(const auto& to : transition.second) {
- grammar.addRule(nonterminalMap.find(from)->second, std::make_pair(input, nonterminalMap.find(to)->second)); // 2a
+ grammar.addRule(nonterminalMap.find(from)->second, ext::make_pair(input, nonterminalMap.find(to)->second)); // 2a
if(automaton.getFinalStates().count(to)) // 2b
grammar.addRule(nonterminalMap.find(from)->second, input);
}
@@ -86,7 +86,7 @@ grammar::RightRG < > ToGrammarRightRG::convert(const automaton::DFA<>& automaton
const DefaultSymbolType& input = transition.first.second;
const DefaultStateType& to = transition.second;
- grammar.addRule(nonterminalMap.find(from)->second, std::make_pair(input, nonterminalMap.find(to)->second)); // 2a
+ grammar.addRule(nonterminalMap.find(from)->second, ext::make_pair(input, nonterminalMap.find(to)->second)); // 2a
if(automaton.getFinalStates().count(to)) // 2b
grammar.addRule(nonterminalMap.find(from)->second, input);
}
diff --git a/alib2algo/src/automaton/determinize/DeterminizeIDPDAPart.cxx b/alib2algo/src/automaton/determinize/DeterminizeIDPDAPart.cxx
index 374979e903437d7dea2637ceda165e8eb4b217de..22b62aadc0af313e49d57988ce7f1697537722ca 100644
--- a/alib2algo/src/automaton/determinize/DeterminizeIDPDAPart.cxx
+++ b/alib2algo/src/automaton/determinize/DeterminizeIDPDAPart.cxx
@@ -40,7 +40,7 @@ automaton::InputDrivenDPDA < > Determinize::determinize ( const automaton::Input
ext::set < DefaultStateType > targetIDPDAStates;
for ( DefaultStateType nfaState : recreateNFAStates ( state ) ) {
- auto iter = nfa.getTransitions ( ).find ( std::make_pair ( std::move ( nfaState ), input ) );
+ auto iter = nfa.getTransitions ( ).find ( ext::make_pair ( std::move ( nfaState ), input ) );
if ( iter != nfa.getTransitions ( ).end ( ) )
targetIDPDAStates.insert ( iter->second.begin ( ), iter->second.end ( ) );
diff --git a/alib2algo/src/automaton/determinize/DeterminizeNFAPart.hxx b/alib2algo/src/automaton/determinize/DeterminizeNFAPart.hxx
index 5acd663c12c442d1f61938e0917dbc2d0a519aa1..e5ab925eff32d4625142dfeff92d01f3199d270c 100644
--- a/alib2algo/src/automaton/determinize/DeterminizeNFAPart.hxx
+++ b/alib2algo/src/automaton/determinize/DeterminizeNFAPart.hxx
@@ -40,7 +40,7 @@ automaton::DFA < SymbolType, ext::set < StateType > > Determinize::determinize (
ext::set < StateType > dfaState;
for ( StateType nfaState : state ) {
- auto iter = nfa.getTransitions ( ).find ( std::make_pair ( std::move ( nfaState ), input ) );
+ auto iter = nfa.getTransitions ( ).find ( ext::make_pair ( std::move ( nfaState ), input ) );
if ( iter != nfa.getTransitions ( ).end ( ) )
dfaState.insert ( iter->second.begin ( ), iter->second.end ( ) );
@@ -88,7 +88,7 @@ automaton::DFA < SymbolType, ext::set < StateType > > Determinize::determinize (
ext::set < StateType > dfaState;
for ( StateType nfaState : state ) {
- auto iter = nfa.getTransitions ( ).find ( std::make_pair ( std::move ( nfaState ), input ) );
+ auto iter = nfa.getTransitions ( ).find ( ext::make_pair ( std::move ( nfaState ), input ) );
if ( iter != nfa.getTransitions ( ).end ( ) )
dfaState.insert ( iter->second.begin ( ), iter->second.end ( ) );
diff --git a/alib2algo/src/automaton/determinize/DeterminizeNFTAPart.cxx b/alib2algo/src/automaton/determinize/DeterminizeNFTAPart.cxx
index bcd4ec43bf013426eb1a4ce67aaee49b745fa47b..3283ce647b7dac21e556cc2f44a8c6c3cfad7869 100644
--- a/alib2algo/src/automaton/determinize/DeterminizeNFTAPart.cxx
+++ b/alib2algo/src/automaton/determinize/DeterminizeNFTAPart.cxx
@@ -77,7 +77,7 @@ DFTA < > Determinize::determinize(const NFTA < > & nfta) {
DefaultStateType newNextState = createDFAState(newNextStates);
if (res.addState(newNextState)) todo.push_back(newNextState);
if (res.addTransition(transition.first.first, newStates, newNextState) && i + 1!= states.size()) {
- transitions.push_back(std::make_pair(std::make_pair(transition.first.first, newStates), newNextState));
+ transitions.push_back(ext::make_pair(ext::make_pair(transition.first.first, newStates), newNextState));
stops.push_back(i + 1);
}
}
diff --git a/alib2algo/src/automaton/determinize/DeterminizeRHDPDAPart.cxx b/alib2algo/src/automaton/determinize/DeterminizeRHDPDAPart.cxx
index 331dacea5ad83e468350551be397f85db1dd32f0..61d6ed13d0f3bd7e3fb1885f36361e8d1f1d4dba 100644
--- a/alib2algo/src/automaton/determinize/DeterminizeRHDPDAPart.cxx
+++ b/alib2algo/src/automaton/determinize/DeterminizeRHDPDAPart.cxx
@@ -24,9 +24,9 @@ void addRetTransition(const DefaultStateType& from, const ext::variant<DefaultEp
}
void retInitial(const DefaultStateType& state, const DefaultSymbolType& pdaSymbol, const ext::variant<DefaultEpsilonType, DefaultSymbolType>& input, const automaton::RealTimeHeightDeterministicNPDA < > & nondeterministic, automaton::RealTimeHeightDeterministicDPDA < > & deterministic, ext::map<ext::tuple<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>, DefaultSymbolType>, DefaultStateType>& rubbishReturnTransitions) {
- const ext::set<std::pair<DefaultStateType, DefaultStateType>> & S = unpackFromStateLabel(state);
+ const ext::set<ext::pair<DefaultStateType, DefaultStateType>> & S = unpackFromStateLabel(state);
- ext::set<std::pair<DefaultStateType, DefaultStateType>> S1;
+ ext::set<ext::pair<DefaultStateType, DefaultStateType>> S1;
for(const auto& entry : S) {
const DefaultStateType& q = entry.first;
const DefaultStateType& q2 = entry.second;
@@ -38,7 +38,7 @@ void retInitial(const DefaultStateType& state, const DefaultSymbolType& pdaSymbo
for(const auto& to : transition.second) {
const DefaultStateType& q1 = to;
- S1.insert(std::make_pair(q, q1));
+ S1.insert(ext::make_pair(q, q1));
}
}
}
@@ -54,11 +54,11 @@ void retInitial(const DefaultStateType& state, const DefaultSymbolType& pdaSymbo
}
void ret(const DefaultStateType& state, const DefaultSymbolType& pdaSymbol, const ext::variant<DefaultEpsilonType, DefaultSymbolType>& input, const automaton::RealTimeHeightDeterministicNPDA < > & nondeterministic, automaton::RealTimeHeightDeterministicDPDA < > & deterministic, ext::map<ext::tuple<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>, DefaultSymbolType>, DefaultStateType>& rubbishReturnTransitions) {
- const ext::set<std::pair<DefaultStateType, DefaultStateType>> & S = unpackFromStateLabel(state);
- const std::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>> & pdaSymbolUnpack = unpackFromDRHDPDAStackSymbol(pdaSymbol);
- const ext::set<std::pair<DefaultStateType, DefaultStateType>>& S1 = unpackFromStateLabel ( pdaSymbolUnpack.first );
+ const ext::set<ext::pair<DefaultStateType, DefaultStateType>> & S = unpackFromStateLabel(state);
+ const ext::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>> & pdaSymbolUnpack = unpackFromDRHDPDAStackSymbol(pdaSymbol);
+ const ext::set<ext::pair<DefaultStateType, DefaultStateType>>& S1 = unpackFromStateLabel ( pdaSymbolUnpack.first );
- ext::set<std::pair<DefaultStateType, DefaultStateType>> update;
+ ext::set<ext::pair<DefaultStateType, DefaultStateType>> update;
for(const auto& transition : nondeterministic.getCallTransitions()) {
if(pdaSymbolUnpack.second != std::get<1>(transition.first)) continue;
@@ -80,14 +80,14 @@ void ret(const DefaultStateType& state, const DefaultSymbolType& pdaSymbol, cons
for(const auto& to2 : transition2.second) {
const DefaultStateType& qI = to2;
- update.insert(std::make_pair(q, qI));
+ update.insert(ext::make_pair(q, qI));
}
}
}
}
}
- ext::set<std::pair<DefaultStateType, DefaultStateType>> S2;
+ ext::set<ext::pair<DefaultStateType, DefaultStateType>> S2;
for(const auto& entry : S1) {
const DefaultStateType& q = entry.first;
const DefaultStateType& q3 = entry.second;
@@ -96,7 +96,7 @@ void ret(const DefaultStateType& state, const DefaultSymbolType& pdaSymbol, cons
const DefaultStateType& qI = entry2.second;
- S2.insert(std::make_pair(q, qI));
+ S2.insert(ext::make_pair(q, qI));
}
}
@@ -118,8 +118,8 @@ void addCallTransition(const DefaultStateType& from, const ext::variant<DefaultE
deterministic.addCallTransition(from, input, to, dvpdaSymbol);
}
-void call(const DefaultStateType& state, const ext::variant<DefaultEpsilonType, DefaultSymbolType>& input, const automaton::RealTimeHeightDeterministicNPDA < > & nondeterministic, automaton::RealTimeHeightDeterministicDPDA < > & deterministic, ext::map<std::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>>, std::pair<DefaultStateType, DefaultSymbolType> >& rubbishCallTransitions) {
- const ext::set<std::pair<DefaultStateType, DefaultStateType>> & S = unpackFromStateLabel(state);
+void call(const DefaultStateType& state, const ext::variant<DefaultEpsilonType, DefaultSymbolType>& input, const automaton::RealTimeHeightDeterministicNPDA < > & nondeterministic, automaton::RealTimeHeightDeterministicDPDA < > & deterministic, ext::map<ext::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>>, ext::pair<DefaultStateType, DefaultSymbolType> >& rubbishCallTransitions) {
+ const ext::set<ext::pair<DefaultStateType, DefaultStateType>> & S = unpackFromStateLabel(state);
ext::set<DefaultStateType> R = retrieveDSubSet(S);
ext::set<DefaultStateType> R1;
@@ -139,9 +139,9 @@ void call(const DefaultStateType& state, const ext::variant<DefaultEpsilonType,
bool R1Empty = R1.empty();
DefaultStateType to = packToStateLabel(createIdentity(std::move(R1)));
- DefaultSymbolType push = packToStackSymbolLabel(std::make_pair(state, input));
+ DefaultSymbolType push = packToStackSymbolLabel(ext::make_pair(state, input));
if(R1Empty) {
- rubbishCallTransitions.insert(std::make_pair(std::make_pair(state, input), std::make_pair(to, push)));
+ rubbishCallTransitions.insert(std::make_pair(ext::make_pair(state, input), ext::make_pair(to, push)));
} else {
addCallTransition(state, input, to, push, deterministic);
}
@@ -154,9 +154,9 @@ void addLocalTransition(const DefaultStateType& from, const ext::variant<Default
deterministic.addLocalTransition(from, input, to);
}
-void local(const DefaultStateType& state, const ext::variant<DefaultEpsilonType, DefaultSymbolType>& input, const automaton::RealTimeHeightDeterministicNPDA < > & nondeterministic, automaton::RealTimeHeightDeterministicDPDA < > & deterministic, ext::map<std::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>>, DefaultStateType>& rubbishLocalTransitions ) {
- const ext::set<std::pair<DefaultStateType, DefaultStateType>> & S = unpackFromStateLabel(state);
- ext::set<std::pair<DefaultStateType, DefaultStateType>> S1;
+void local(const DefaultStateType& state, const ext::variant<DefaultEpsilonType, DefaultSymbolType>& input, const automaton::RealTimeHeightDeterministicNPDA < > & nondeterministic, automaton::RealTimeHeightDeterministicDPDA < > & deterministic, ext::map<ext::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>>, DefaultStateType>& rubbishLocalTransitions ) {
+ const ext::set<ext::pair<DefaultStateType, DefaultStateType>> & S = unpackFromStateLabel(state);
+ ext::set<ext::pair<DefaultStateType, DefaultStateType>> S1;
for(const auto& entry : S) {
const DefaultStateType & q = entry.first;
@@ -168,7 +168,7 @@ void local(const DefaultStateType& state, const ext::variant<DefaultEpsilonType,
for(const auto& to : transition.second) {
const DefaultStateType & q1 = to;
- S1.insert(std::make_pair(q, q1));
+ S1.insert(ext::make_pair(q, q1));
}
}
}
@@ -176,7 +176,7 @@ void local(const DefaultStateType& state, const ext::variant<DefaultEpsilonType,
bool S1Empty = S1.empty();
DefaultStateType to(packToStateLabel(std::move(S1)));
if(S1Empty) {
- rubbishLocalTransitions.insert(std::make_pair(std::make_pair(state, input), to));
+ rubbishLocalTransitions.insert(std::make_pair(ext::make_pair(state, input), to));
} else {
addLocalTransition(state, input, to, deterministic);
}
@@ -215,11 +215,11 @@ automaton::RealTimeHeightDeterministicDPDA < > Determinize::determinize(const au
ext::set<DefaultStateType> rubbishStates = {DefaultStateType(packToStateLabel({}))};
ext::map<ext::tuple<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>, DefaultSymbolType>, DefaultStateType> rubbishReturnTransitions;
- ext::map<std::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>>, std::pair<DefaultStateType, DefaultSymbolType> > rubbishCallTransitions;
- ext::map<std::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>>, DefaultStateType> rubbishLocalTransitions;
+ ext::map<ext::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>>, ext::pair<DefaultStateType, DefaultSymbolType> > rubbishCallTransitions;
+ ext::map<ext::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>>, DefaultStateType> rubbishLocalTransitions;
for(;;) {
- ext::set<std::pair<DefaultStateType, DefaultSymbolType>> stateSymbols = existsDirtyStateSymbol(d, rubbishStates, rubbishCallTransitions, rubbishReturnTransitions, n);
+ ext::set<ext::pair<DefaultStateType, DefaultSymbolType>> stateSymbols = existsDirtyStateSymbol(d, rubbishStates, rubbishCallTransitions, rubbishReturnTransitions, n);
ext::set<DefaultStateType> states = existsDirtyState(d, rubbishStates, rubbishCallTransitions, rubbishLocalTransitions, n);
if(stateSymbols.empty() && states.empty()) break;
diff --git a/alib2algo/src/automaton/determinize/DeterminizeVPAPart.cxx b/alib2algo/src/automaton/determinize/DeterminizeVPAPart.cxx
index 7f5965a12b56b8e0d0fead309499f7954330fbb8..c7f2579ec8a670fabae838551040c1053657c1f3 100644
--- a/alib2algo/src/automaton/determinize/DeterminizeVPAPart.cxx
+++ b/alib2algo/src/automaton/determinize/DeterminizeVPAPart.cxx
@@ -23,9 +23,9 @@ void addRetTransition(const DefaultStateType& from, const DefaultSymbolType& inp
}
void retInitial(const DefaultStateType& state, const DefaultSymbolType& pdaSymbol, const DefaultSymbolType& input, const automaton::VisiblyPushdownNPDA < > & nondeterministic, automaton::VisiblyPushdownDPDA < > & deterministic) {
- const ext::set<std::pair<DefaultStateType, DefaultStateType>> & S = unpackFromStateLabel(state);
+ const ext::set<ext::pair<DefaultStateType, DefaultStateType>> & S = unpackFromStateLabel(state);
- ext::set<std::pair<DefaultStateType, DefaultStateType>> S1;
+ ext::set<ext::pair<DefaultStateType, DefaultStateType>> S1;
for(const auto& entry : S) {
const DefaultStateType& q = entry.first;
const DefaultStateType& q2 = entry.second;
@@ -37,7 +37,7 @@ void retInitial(const DefaultStateType& state, const DefaultSymbolType& pdaSymbo
for(const auto& to : transition.second) {
const DefaultStateType& q1 = to;
- S1.insert(std::make_pair(q, q1));
+ S1.insert(ext::make_pair(q, q1));
}
}
}
@@ -46,11 +46,11 @@ void retInitial(const DefaultStateType& state, const DefaultSymbolType& pdaSymbo
}
void ret(const DefaultStateType& state, const DefaultSymbolType& pdaSymbol, const DefaultSymbolType& input, const automaton::VisiblyPushdownNPDA < > & nondeterministic, automaton::VisiblyPushdownDPDA < > & deterministic) {
- const ext::set<std::pair<DefaultStateType, DefaultStateType>> & S = unpackFromStateLabel(state);
- const std::pair<DefaultStateType, DefaultSymbolType> & pdaSymbolUnpack = unpackFromDVPAStackSymbol(pdaSymbol);
- const ext::set<std::pair<DefaultStateType, DefaultStateType>>& S1 = unpackFromStateLabel ( pdaSymbolUnpack.first );
+ const ext::set<ext::pair<DefaultStateType, DefaultStateType>> & S = unpackFromStateLabel(state);
+ const ext::pair<DefaultStateType, DefaultSymbolType> & pdaSymbolUnpack = unpackFromDVPAStackSymbol(pdaSymbol);
+ const ext::set<ext::pair<DefaultStateType, DefaultStateType>>& S1 = unpackFromStateLabel ( pdaSymbolUnpack.first );
- ext::set<std::pair<DefaultStateType, DefaultStateType>> update;
+ ext::set<ext::pair<DefaultStateType, DefaultStateType>> update;
for(const auto& transition : nondeterministic.getCallTransitions()) {
if(pdaSymbolUnpack.second != std::get<1>(transition.first)) continue;
@@ -72,14 +72,14 @@ void ret(const DefaultStateType& state, const DefaultSymbolType& pdaSymbol, cons
for(const auto& to2 : transition2.second) {
const DefaultStateType& qI = to2;
- update.insert(std::make_pair(q, qI));
+ update.insert(ext::make_pair(q, qI));
}
}
}
}
}
- ext::set<std::pair<DefaultStateType, DefaultStateType>> S2;
+ ext::set<ext::pair<DefaultStateType, DefaultStateType>> S2;
for(const auto& entry : S1) {
const DefaultStateType& q = entry.first;
const DefaultStateType& q3 = entry.second;
@@ -88,7 +88,7 @@ void ret(const DefaultStateType& state, const DefaultSymbolType& pdaSymbol, cons
const DefaultStateType& qI = entry2.second;
- S2.insert(std::make_pair(q, qI));
+ S2.insert(ext::make_pair(q, qI));
}
}
@@ -104,7 +104,7 @@ void addCallTransition(const DefaultStateType& from, const DefaultSymbolType& in
}
void call(const DefaultStateType& state, const DefaultSymbolType& input, const automaton::VisiblyPushdownNPDA < > & nondeterministic, automaton::VisiblyPushdownDPDA < > & deterministic) {
- const ext::set<std::pair<DefaultStateType, DefaultStateType>> & S = unpackFromStateLabel(state);
+ const ext::set<ext::pair<DefaultStateType, DefaultStateType>> & S = unpackFromStateLabel(state);
ext::set<DefaultStateType> R = retrieveDSubSet(S);
ext::set<DefaultStateType> R1;
@@ -122,7 +122,7 @@ void call(const DefaultStateType& state, const DefaultSymbolType& input, const a
}
}
- addCallTransition(state, input, DefaultStateType(packToStateLabel(createIdentity(std::move(R1)))), packToStackSymbolLabel(std::make_pair(state, input)), deterministic);
+ addCallTransition(state, input, DefaultStateType(packToStateLabel(createIdentity(std::move(R1)))), packToStackSymbolLabel(ext::make_pair(state, input)), deterministic);
}
void addLocalTransition(const DefaultStateType& from, const DefaultSymbolType& input, const DefaultStateType& to, automaton::VisiblyPushdownDPDA < > & deterministic) {
@@ -133,8 +133,8 @@ void addLocalTransition(const DefaultStateType& from, const DefaultSymbolType& i
}
void local(const DefaultStateType& state, const DefaultSymbolType& input, const automaton::VisiblyPushdownNPDA < > & nondeterministic, automaton::VisiblyPushdownDPDA < > & deterministic) {
- const ext::set<std::pair<DefaultStateType, DefaultStateType>> & S = unpackFromStateLabel(state);
- ext::set<std::pair<DefaultStateType, DefaultStateType>> S1;
+ const ext::set<ext::pair<DefaultStateType, DefaultStateType>> & S = unpackFromStateLabel(state);
+ ext::set<ext::pair<DefaultStateType, DefaultStateType>> S1;
for(const auto& entry : S) {
const DefaultStateType & q = entry.first;
@@ -146,7 +146,7 @@ void local(const DefaultStateType& state, const DefaultSymbolType& input, const
for(const auto& to : transition.second) {
const DefaultStateType & q1 = to;
- S1.insert(std::make_pair(q, q1));
+ S1.insert(ext::make_pair(q, q1));
}
}
}
@@ -164,11 +164,11 @@ automaton::VisiblyPushdownDPDA < > Determinize::determinize(const automaton::Vis
ext::set<DefaultStateType> rubbishStates = {DefaultStateType(packToStateLabel({}))};
ext::map<ext::tuple<DefaultStateType, DefaultSymbolType, DefaultSymbolType>, DefaultStateType> rubbishReturnTransitions;
- ext::map<std::pair<DefaultStateType, DefaultSymbolType>, std::pair<DefaultStateType, DefaultSymbolType> > rubbishCallTransitions;
- ext::map<std::pair<DefaultStateType, DefaultSymbolType>, DefaultStateType> rubbishLocalTransitions;
+ ext::map<ext::pair<DefaultStateType, DefaultSymbolType>, ext::pair<DefaultStateType, DefaultSymbolType> > rubbishCallTransitions;
+ ext::map<ext::pair<DefaultStateType, DefaultSymbolType>, DefaultStateType> rubbishLocalTransitions;
for(;;) {
- ext::set<std::pair<DefaultStateType, DefaultSymbolType>> stateSymbols = existsDirtyStateSymbol(d, rubbishStates, rubbishCallTransitions, rubbishReturnTransitions, n);
+ ext::set<ext::pair<DefaultStateType, DefaultSymbolType>> stateSymbols = existsDirtyStateSymbol(d, rubbishStates, rubbishCallTransitions, rubbishReturnTransitions, n);
ext::set<DefaultStateType> states = existsDirtyState(d, rubbishStates, rubbishCallTransitions, rubbishLocalTransitions, n);
if(stateSymbols.empty() && states.empty()) break;
diff --git a/alib2algo/src/automaton/determinize/common/RHDPDACommon.cpp b/alib2algo/src/automaton/determinize/common/RHDPDACommon.cpp
index 558b23cf3f69d5bfd24ada0e0bea7122f2fd35cf..2925f4c7f46f94f1f84507ed1dc60a41801afbb6 100644
--- a/alib2algo/src/automaton/determinize/common/RHDPDACommon.cpp
+++ b/alib2algo/src/automaton/determinize/common/RHDPDACommon.cpp
@@ -12,31 +12,31 @@ namespace automaton {
namespace determinize {
-DefaultStateType packToStateLabel(ext::set<std::pair<DefaultStateType, DefaultStateType>>&& data) {
- return DefaultStateType ( alib::AnyObject < ext::set<std::pair<DefaultStateType, DefaultStateType>> > ( std::move ( data ) ) );
+DefaultStateType packToStateLabel(ext::set<ext::pair<DefaultStateType, DefaultStateType>>&& data) {
+ return DefaultStateType ( alib::AnyObject < ext::set<ext::pair<DefaultStateType, DefaultStateType>> > ( std::move ( data ) ) );
}
-const ext::set<std::pair<DefaultStateType, DefaultStateType>> & unpackFromStateLabel(const DefaultStateType& data) {
- return static_cast < const alib::AnyObject < ext::set<std::pair<DefaultStateType, DefaultStateType>> > & > ( data.getData ( ) ).getData ( );
+const ext::set<ext::pair<DefaultStateType, DefaultStateType>> & unpackFromStateLabel(const DefaultStateType& data) {
+ return static_cast < const alib::AnyObject < ext::set<ext::pair<DefaultStateType, DefaultStateType>> > & > ( data.getData ( ) ).getData ( );
}
-DefaultSymbolType packToStackSymbolLabel(std::pair<DefaultStateType, DefaultSymbolType>&& data) {
- return DefaultSymbolType ( alib::AnyObject < std::pair<DefaultStateType, DefaultSymbolType> > ( std::move ( data ) ) );
+DefaultSymbolType packToStackSymbolLabel(ext::pair<DefaultStateType, DefaultSymbolType>&& data) {
+ return DefaultSymbolType ( alib::AnyObject < ext::pair<DefaultStateType, DefaultSymbolType> > ( std::move ( data ) ) );
}
-const std::pair<DefaultStateType, DefaultSymbolType> & unpackFromDVPAStackSymbol(const DefaultSymbolType& symbol) {
- return static_cast < const alib::AnyObject < std::pair<DefaultStateType, DefaultSymbolType> > & > ( symbol.getData ( ) ).getData ( );
+const ext::pair<DefaultStateType, DefaultSymbolType> & unpackFromDVPAStackSymbol(const DefaultSymbolType& symbol) {
+ return static_cast < const alib::AnyObject < ext::pair<DefaultStateType, DefaultSymbolType> > & > ( symbol.getData ( ) ).getData ( );
}
-DefaultSymbolType packToStackSymbolLabel(std::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>>&& data) {
- return DefaultSymbolType ( alib::AnyObject < std::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>> > ( std::move ( data ) ) );
+DefaultSymbolType packToStackSymbolLabel(ext::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>>&& data) {
+ return DefaultSymbolType ( alib::AnyObject < ext::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>> > ( std::move ( data ) ) );
}
-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 ( );
+const ext::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>> & unpackFromDRHDPDAStackSymbol(const DefaultSymbolType& symbol) {
+ return static_cast < const alib::AnyObject < ext::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>> > & > ( symbol.getData ( ) ).getData ( );
}
-ext::set<DefaultStateType> retrieveDSubSet(const ext::set<std::pair<DefaultStateType, DefaultStateType>>& localOperation) {
+ext::set<DefaultStateType> retrieveDSubSet(const ext::set<ext::pair<DefaultStateType, DefaultStateType>>& localOperation) {
ext::set<DefaultStateType> id;
for(const auto& entry : localOperation) {
id.insert(entry.second);
@@ -44,16 +44,16 @@ ext::set<DefaultStateType> retrieveDSubSet(const ext::set<std::pair<DefaultState
return id;
}
-ext::set<std::pair<DefaultStateType, DefaultStateType>> createIdentity(const ext::set<DefaultStateType>& states) {
- ext::set<std::pair<DefaultStateType, DefaultStateType>> id;
+ext::set<ext::pair<DefaultStateType, DefaultStateType>> createIdentity(const ext::set<DefaultStateType>& states) {
+ ext::set<ext::pair<DefaultStateType, DefaultStateType>> id;
for(const DefaultStateType& state : states) {
- id.insert(std::make_pair(state, state));
+ id.insert(ext::make_pair(state, state));
}
return id;
}
template<class T, class S, class R>
-ext::set<DefaultStateType> existsDirtyState(const T& d, const ext::set<DefaultStateType>& rubbishStates, const ext::map<std::pair<DefaultStateType, S>, std::pair<DefaultStateType, DefaultSymbolType> >& rubbishCallTransitions, const ext::map<std::pair<DefaultStateType, S>, DefaultStateType>& rubbishLocalTransitions, const R& n) {
+ext::set<DefaultStateType> existsDirtyState(const T& d, const ext::set<DefaultStateType>& rubbishStates, const ext::map<ext::pair<DefaultStateType, S>, ext::pair<DefaultStateType, DefaultSymbolType> >& rubbishCallTransitions, const ext::map<ext::pair<DefaultStateType, S>, DefaultStateType>& rubbishLocalTransitions, const R& n) {
ext::set<DefaultStateType> dirtyStates;
ext::set<DefaultStateType> states = d.getStates();
@@ -104,8 +104,8 @@ ext::set<DefaultStateType> existsDirtyState(const T& d, const ext::set<DefaultSt
return dirtyStates;
}
-template ext::set<DefaultStateType> existsDirtyState(const automaton::VisiblyPushdownDPDA < > & d, const ext::set<DefaultStateType>& rubbishStates, const ext::map<std::pair<DefaultStateType, DefaultSymbolType>, std::pair<DefaultStateType, DefaultSymbolType> >& rubbishCallTransitions, const ext::map<std::pair<DefaultStateType, DefaultSymbolType>, DefaultStateType>& rubbishLocalTransitions, const automaton::VisiblyPushdownNPDA < > & n);
-template ext::set<DefaultStateType> existsDirtyState(const automaton::RealTimeHeightDeterministicDPDA < > & d, const ext::set<DefaultStateType>& rubbishStates, const ext::map<std::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>>, std::pair<DefaultStateType, DefaultSymbolType> >& rubbishCallTransitions, const ext::map<std::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>>, DefaultStateType>& rubbishLocalTransitions, const automaton::RealTimeHeightDeterministicNPDA < > & n);
+template ext::set<DefaultStateType> existsDirtyState(const automaton::VisiblyPushdownDPDA < > & d, const ext::set<DefaultStateType>& rubbishStates, const ext::map<ext::pair<DefaultStateType, DefaultSymbolType>, ext::pair<DefaultStateType, DefaultSymbolType> >& rubbishCallTransitions, const ext::map<ext::pair<DefaultStateType, DefaultSymbolType>, DefaultStateType>& rubbishLocalTransitions, const automaton::VisiblyPushdownNPDA < > & n);
+template ext::set<DefaultStateType> existsDirtyState(const automaton::RealTimeHeightDeterministicDPDA < > & d, const ext::set<DefaultStateType>& rubbishStates, const ext::map<ext::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>>, ext::pair<DefaultStateType, DefaultSymbolType> >& rubbishCallTransitions, const ext::map<ext::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>>, DefaultStateType>& rubbishLocalTransitions, const automaton::RealTimeHeightDeterministicNPDA < > & n);
void localClosure(ext::set<DefaultStateType>& states, const ext::set<DefaultStateType>& oldStates, const automaton::RealTimeHeightDeterministicDPDA < > & d) {
ext::set<DefaultStateType> newStates;
@@ -172,8 +172,8 @@ void localClosure(ext::set<DefaultStateType>& states, const ext::set<DefaultStat
}
template<class T, class S, class R>
-ext::set<std::pair<DefaultStateType, DefaultSymbolType>> existsDirtyStateSymbol(const T& d, const ext::set<DefaultStateType>& rubbishStates, const ext::map<std::pair<DefaultStateType, S>, std::pair<DefaultStateType, DefaultSymbolType> >& rubbishCallTransitions, const ext::map<ext::tuple<DefaultStateType, S, DefaultSymbolType>, DefaultStateType>& rubbishReturnTransitions, const R& n) {
- ext::set<std::pair<DefaultStateType, DefaultSymbolType>> dirtyStateSymbols;
+ext::set<ext::pair<DefaultStateType, DefaultSymbolType>> existsDirtyStateSymbol(const T& d, const ext::set<DefaultStateType>& rubbishStates, const ext::map<ext::pair<DefaultStateType, S>, ext::pair<DefaultStateType, DefaultSymbolType> >& rubbishCallTransitions, const ext::map<ext::tuple<DefaultStateType, S, DefaultSymbolType>, DefaultStateType>& rubbishReturnTransitions, const R& n) {
+ ext::set<ext::pair<DefaultStateType, DefaultSymbolType>> dirtyStateSymbols;
ext::set<DefaultStateType> states = d.getStates();
states.insert(rubbishStates.begin(), rubbishStates.end());
@@ -220,13 +220,13 @@ ext::set<std::pair<DefaultStateType, DefaultSymbolType>> existsDirtyStateSymbol(
}
for(const DefaultSymbolType& topSymbol : topSymbols)
- dirtyStateSymbols.insert(std::make_pair(state, topSymbol));
+ dirtyStateSymbols.insert(ext::make_pair(state, topSymbol));
}
return dirtyStateSymbols;
}
-template ext::set<std::pair<DefaultStateType, DefaultSymbolType>> existsDirtyStateSymbol(const automaton::VisiblyPushdownDPDA < > & d, const ext::set<DefaultStateType>& rubbishStates, const ext::map<std::pair<DefaultStateType, DefaultSymbolType>, std::pair<DefaultStateType, DefaultSymbolType> >& rubbishCallTransitions, const ext::map<ext::tuple<DefaultStateType, DefaultSymbolType, DefaultSymbolType>, DefaultStateType>& rubbishReturnTransitions, const automaton::VisiblyPushdownNPDA < > & n);
-template ext::set<std::pair<DefaultStateType, DefaultSymbolType>> existsDirtyStateSymbol(const automaton::RealTimeHeightDeterministicDPDA < > & d, const ext::set<DefaultStateType>& rubbishStates, const ext::map<std::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>>, std::pair<DefaultStateType, DefaultSymbolType> >& rubbishCallTransitions, const ext::map<ext::tuple<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>, DefaultSymbolType>, DefaultStateType>& rubbishReturnTransitions, const automaton::RealTimeHeightDeterministicNPDA < > & n);
+template ext::set<ext::pair<DefaultStateType, DefaultSymbolType>> existsDirtyStateSymbol(const automaton::VisiblyPushdownDPDA < > & d, const ext::set<DefaultStateType>& rubbishStates, const ext::map<ext::pair<DefaultStateType, DefaultSymbolType>, ext::pair<DefaultStateType, DefaultSymbolType> >& rubbishCallTransitions, const ext::map<ext::tuple<DefaultStateType, DefaultSymbolType, DefaultSymbolType>, DefaultStateType>& rubbishReturnTransitions, const automaton::VisiblyPushdownNPDA < > & n);
+template ext::set<ext::pair<DefaultStateType, DefaultSymbolType>> existsDirtyStateSymbol(const automaton::RealTimeHeightDeterministicDPDA < > & d, const ext::set<DefaultStateType>& rubbishStates, const ext::map<ext::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>>, ext::pair<DefaultStateType, DefaultSymbolType> >& rubbishCallTransitions, const ext::map<ext::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 4187607d117472928936d825213229cdaf187d81..742b9db219fce2f9767e2c1a0ed8103824cd7a74 100644
--- a/alib2algo/src/automaton/determinize/common/RHDPDACommon.h
+++ b/alib2algo/src/automaton/determinize/common/RHDPDACommon.h
@@ -14,30 +14,30 @@ namespace automaton {
namespace determinize {
-DefaultStateType packToStateLabel(ext::set<std::pair<DefaultStateType, DefaultStateType>>&& data);
+DefaultStateType packToStateLabel(ext::set<ext::pair<DefaultStateType, DefaultStateType>>&& data);
-const ext::set<std::pair<DefaultStateType, DefaultStateType>> & unpackFromStateLabel(const DefaultStateType& data);
+const ext::set<ext::pair<DefaultStateType, DefaultStateType>> & unpackFromStateLabel(const DefaultStateType& data);
-DefaultSymbolType packToStackSymbolLabel(std::pair<DefaultStateType, DefaultSymbolType>&& data);
+DefaultSymbolType packToStackSymbolLabel(ext::pair<DefaultStateType, DefaultSymbolType>&& data);
-const std::pair<DefaultStateType, DefaultSymbolType> & unpackFromDVPAStackSymbol(const DefaultSymbolType& symbol);
+const ext::pair<DefaultStateType, DefaultSymbolType> & unpackFromDVPAStackSymbol(const DefaultSymbolType& symbol);
-DefaultSymbolType packToStackSymbolLabel(std::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>>&& data);
+DefaultSymbolType packToStackSymbolLabel(ext::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>>&& data);
-const std::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>> & unpackFromDRHDPDAStackSymbol(const DefaultSymbolType& symbol);
+const ext::pair<DefaultStateType, ext::variant<DefaultEpsilonType, DefaultSymbolType>> & unpackFromDRHDPDAStackSymbol(const DefaultSymbolType& symbol);
-ext::set<DefaultStateType> retrieveDSubSet(const ext::set<std::pair<DefaultStateType, DefaultStateType>>& localOperation);
+ext::set<DefaultStateType> retrieveDSubSet(const ext::set<ext::pair<DefaultStateType, DefaultStateType>>& localOperation);
-ext::set<std::pair<DefaultStateType, DefaultStateType>> createIdentity(const ext::set<DefaultStateType>& states);
+ext::set<ext::pair<DefaultStateType, DefaultStateType>> createIdentity(const ext::set<DefaultStateType>& states);
template<class T, class S, class R>
-ext::set<DefaultStateType> existsDirtyState(const T& d, const ext::set<DefaultStateType>& rubbishStates, const ext::map<std::pair<DefaultStateType, S>, std::pair<DefaultStateType, DefaultSymbolType> >& rubbishCallTransitions, const ext::map<std::pair<DefaultStateType, S>, DefaultStateType>& rubbishLocalTransitions, const R& n);
+ext::set<DefaultStateType> existsDirtyState(const T& d, const ext::set<DefaultStateType>& rubbishStates, const ext::map<ext::pair<DefaultStateType, S>, ext::pair<DefaultStateType, DefaultSymbolType> >& rubbishCallTransitions, const ext::map<ext::pair<DefaultStateType, S>, DefaultStateType>& rubbishLocalTransitions, const R& n);
void localClosure(ext::set<DefaultStateType>& states, const ext::set<DefaultStateType>& oldStates, const automaton::RealTimeHeightDeterministicDPDA < > & d);
void localClosure(ext::set<DefaultStateType>& states, const ext::set<DefaultStateType>& oldStates, const automaton::VisiblyPushdownDPDA < > & d);
template<class T, class S, class R>
-ext::set<std::pair<DefaultStateType, DefaultSymbolType>> existsDirtyStateSymbol(const T& d, const ext::set<DefaultStateType>& rubbishStates, const ext::map<std::pair<DefaultStateType, S>, std::pair<DefaultStateType, DefaultSymbolType> >& rubbishCallTransitions, const ext::map<ext::tuple<DefaultStateType, S, DefaultSymbolType>, DefaultStateType>& rubbishReturnTransitions, const R& n);
+ext::set<ext::pair<DefaultStateType, DefaultSymbolType>> existsDirtyStateSymbol(const T& d, const ext::set<DefaultStateType>& rubbishStates, const ext::map<ext::pair<DefaultStateType, S>, ext::pair<DefaultStateType, DefaultSymbolType> >& rubbishCallTransitions, const ext::map<ext::tuple<DefaultStateType, S, DefaultSymbolType>, DefaultStateType>& rubbishReturnTransitions, const R& n);
} /* namespace determinize */
diff --git a/alib2algo/src/automaton/properties/EpsilonClosure.h b/alib2algo/src/automaton/properties/EpsilonClosure.h
index 6d4b9c078809c16d14a58e156ebc3545b1f28464..4a4d5c5773269ddd9a470f286d666a406633d636 100644
--- a/alib2algo/src/automaton/properties/EpsilonClosure.h
+++ b/alib2algo/src/automaton/properties/EpsilonClosure.h
@@ -70,7 +70,7 @@ ext::set<StateType> EpsilonClosure::epsilonClosure( const automaton::EpsilonNFA
visited[ p ] = true;
closure.insert( p );
- auto tos = fsm.getTransitions( ).find(std::make_pair ( p, ext::variant < EpsilonType, SymbolType >::template from < EpsilonType > ( ) ) );
+ auto tos = fsm.getTransitions( ).find(ext::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/run/Run.h b/alib2algo/src/automaton/run/Run.h
index 84caf5f1f18a002e89b288a89eeb12efe3862871..a7cc67e340a5f1f5447f96280054916797b996b4 100644
--- a/alib2algo/src/automaton/run/Run.h
+++ b/alib2algo/src/automaton/run/Run.h
@@ -36,9 +36,9 @@ namespace run {
class Run {
template < class SymbolType, class RankType, class StateType >
- static std::pair < bool, StateType > calculateState ( const automaton::DFTA < SymbolType, RankType, StateType > & automaton, const ext::tree < common::ranked_symbol < SymbolType, RankType > > & node, ext::set < unsigned > & occ, unsigned & i );
+ static ext::pair < bool, StateType > calculateState ( const automaton::DFTA < SymbolType, RankType, StateType > & automaton, const ext::tree < common::ranked_symbol < SymbolType, RankType > > & node, ext::set < unsigned > & occ, unsigned & i );
template < class SymbolType, class RankType, class StateType >
- static std::pair < bool, ext::set < StateType > > calculateStates ( const automaton::NFTA < SymbolType, RankType, StateType > & automaton, const ext::tree < common::ranked_symbol < SymbolType, RankType > > & node, ext::set < unsigned > & occ, unsigned & i );
+ static ext::pair < bool, ext::set < StateType > > calculateStates ( const automaton::NFTA < SymbolType, RankType, StateType > & automaton, const ext::tree < common::ranked_symbol < SymbolType, RankType > > & node, ext::set < unsigned > & occ, unsigned & i );
template < class SymbolType >
static bool canPop ( const ext::deque < SymbolType > & pushdownStore, const ext::vector < SymbolType > & pop );
@@ -79,7 +79,7 @@ ext::tuple < bool, StateType, ext::set < unsigned > > Run::calculateState ( cons
std::clog << state << std::endl;
for ( const SymbolType & symbol : string.getContent ( ) ) {
- auto transition = automaton.getTransitions ( ).find ( std::make_pair ( state, symbol ) );
+ auto transition = automaton.getTransitions ( ).find ( ext::make_pair ( state, symbol ) );
if ( transition == automaton.getTransitions ( ).end ( ) ) {
res = false;
@@ -121,7 +121,7 @@ ext::tuple < bool, ext::set < StateType >, ext::set < unsigned > > Run::calculat
ext::set < StateType > next;
for ( const StateType & state : states ) {
- auto transitions = automaton.getTransitions ( ).find ( std::make_pair ( state, symbol ) );
+ auto transitions = automaton.getTransitions ( ).find ( ext::make_pair ( state, symbol ) );
if ( transitions == automaton.getTransitions ( ).end ( ) ) continue;
@@ -145,7 +145,7 @@ ext::tuple < bool, ext::set < StateType >, ext::set < unsigned > > Run::calculat
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
template < class SymbolType, class RankType, class StateType >
-std::pair < bool, StateType > Run::calculateState ( const automaton::DFTA < SymbolType, RankType, StateType > & automaton, const ext::tree < common::ranked_symbol < SymbolType, RankType > > & node, ext::set < unsigned > & occ, unsigned & i ) {
+ext::pair < bool, StateType > Run::calculateState ( const automaton::DFTA < SymbolType, RankType, StateType > & automaton, const ext::tree < common::ranked_symbol < SymbolType, RankType > > & node, ext::set < unsigned > & occ, unsigned & i ) {
ext::vector < StateType > states;
states.reserve ( ( size_t ) node.getData ( ).getRank ( ) );
@@ -156,7 +156,7 @@ std::pair < bool, StateType > Run::calculateState ( const automaton::DFTA < Symb
bool sign = true;
for ( const ext::tree < common::ranked_symbol < SymbolType, RankType > > & child : node.getChildren ( ) ) {
- std::pair < bool, StateType > res = calculateState ( automaton, child, occ, i );
+ ext::pair < bool, StateType > res = calculateState ( automaton, child, occ, i );
if ( res.first == false )
sign = false;
@@ -164,11 +164,11 @@ std::pair < bool, StateType > Run::calculateState ( const automaton::DFTA < Symb
states.push_back ( res.second );
}
- if ( !sign ) return std::make_pair ( false, label::FailStateLabel::instance < StateType > ( ) );
+ if ( !sign ) return ext::make_pair ( false, label::FailStateLabel::instance < StateType > ( ) );
- const auto & it = automaton.getTransitions ( ).find ( std::make_pair ( node.getData ( ), states ) );
+ const auto & it = automaton.getTransitions ( ).find ( ext::make_pair ( node.getData ( ), states ) );
- if ( it == automaton.getTransitions ( ).end ( ) ) return std::make_pair ( false, label::FailStateLabel::instance < StateType > ( ) );
+ if ( it == automaton.getTransitions ( ).end ( ) ) return ext::make_pair ( false, label::FailStateLabel::instance < StateType > ( ) );
StateType state = it->second;
@@ -177,14 +177,14 @@ std::pair < bool, StateType > Run::calculateState ( const automaton::DFTA < Symb
if ( common::GlobalData::verbose )
std::clog << state << std::endl;
- return std::make_pair ( true, state );
+ return ext::make_pair ( true, state );
}
template < class SymbolType, class RankType, class StateType >
ext::tuple < bool, StateType, ext::set < unsigned > > Run::calculateState ( const automaton::DFTA < SymbolType, RankType, StateType > & automaton, const tree::RankedTree < SymbolType, RankType > & tree ) {
ext::set < unsigned > occ;
unsigned i = 0;
- std::pair < bool, StateType > res = calculateState ( automaton, tree.getContent ( ), occ, i );
+ ext::pair < bool, StateType > res = calculateState ( automaton, tree.getContent ( ), occ, i );
return ext::make_tuple ( res.first, res.second, occ );
}
@@ -192,7 +192,7 @@ ext::tuple < bool, StateType, ext::set < unsigned > > Run::calculateState ( cons
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
template < class SymbolType, class RankType, class StateType >
-std::pair < bool, ext::set < StateType > > Run::calculateStates ( const automaton::NFTA < SymbolType, RankType, StateType > & automaton, const ext::tree < common::ranked_symbol < SymbolType, RankType > > & node, ext::set < unsigned > & occ, unsigned & i ) {
+ext::pair < bool, ext::set < StateType > > Run::calculateStates ( const automaton::NFTA < SymbolType, RankType, StateType > & automaton, const ext::tree < common::ranked_symbol < SymbolType, RankType > > & node, ext::set < unsigned > & occ, unsigned & i ) {
ext::vector < ext::set < StateType > > resStates;
resStates.reserve ( ( size_t ) node.getData ( ).getRank ( ) );
@@ -234,14 +234,14 @@ std::pair < bool, ext::set < StateType > > Run::calculateStates ( const automato
if ( common::GlobalData::verbose )
std::clog << states << std::endl;
- return std::make_pair ( sign, states );
+ return ext::make_pair ( sign, states );
}
template < class SymbolType, class RankType, class StateType >
ext::tuple < bool, ext::set < StateType >, ext::set < unsigned > > Run::calculateStates ( const automaton::NFTA < SymbolType, RankType, StateType > & automaton, const tree::RankedTree < SymbolType, RankType > & tree ) {
ext::set < unsigned > occ;
unsigned i = 0;
- std::pair < bool, ext::set < StateType > > res = calculateStates ( automaton, tree.getContent ( ), occ, i );
+ ext::pair < bool, ext::set < StateType > > res = calculateStates ( automaton, tree.getContent ( ), occ, i );
return ext::make_tuple ( res.first, res.second, occ );
}
@@ -281,7 +281,7 @@ ext::tuple < bool, StateType, ext::set < unsigned >, ext::deque < PushdownStoreS
std::clog << state << std::endl;
for ( const InputSymbolType & symbol : string.getContent ( ) ) {
- auto transition = automaton.getTransitions ( ).find ( std::make_pair ( state, symbol ) );
+ auto transition = automaton.getTransitions ( ).find ( ext::make_pair ( state, symbol ) );
if ( transition == automaton.getTransitions ( ).end ( ) ) {
res = false;
@@ -332,7 +332,7 @@ ext::tuple < bool, StateType, ext::set < unsigned >, ext::deque < PushdownStoreS
for ( const InputSymbolType & symbol : string.getContent ( ) ) {
if ( automaton.getCallInputAlphabet ( ).count ( symbol ) ) {
- auto transition = automaton.getCallTransitions ( ).find ( std::make_pair ( state, symbol ) );
+ auto transition = automaton.getCallTransitions ( ).find ( ext::make_pair ( state, symbol ) );
if ( transition == automaton.getCallTransitions ( ).end ( ) ) {
res = false;
@@ -353,7 +353,7 @@ ext::tuple < bool, StateType, ext::set < unsigned >, ext::deque < PushdownStoreS
state = transition->second;
} else if ( automaton.getLocalInputAlphabet ( ).count ( symbol ) ) {
- auto transition = automaton.getLocalTransitions ( ).find ( std::make_pair ( state, symbol ) );
+ auto transition = automaton.getLocalTransitions ( ).find ( ext::make_pair ( state, symbol ) );
if ( transition == automaton.getLocalTransitions ( ).end ( ) ) {
res = false;
@@ -398,13 +398,13 @@ ext::tuple < bool, StateType, ext::set < unsigned >, ext::deque < PushdownStoreS
for ( auto symbolIter = string.getContent ( ).begin ( ); symbolIter != string.getContent ( ).end ( ); ) {
- auto callTransition = automaton.getCallTransitions ( ).find ( std::make_pair ( state, * symbolIter ) );
+ auto callTransition = automaton.getCallTransitions ( ).find ( ext::make_pair ( state, * symbolIter ) );
if ( callTransition != automaton.getCallTransitions ( ).end ( ) ) {
symbolIter++;
i++;
} else {
- callTransition = automaton.getCallTransitions ( ).find ( std::make_pair ( state, EpsilonType ( ) ) );
+ callTransition = automaton.getCallTransitions ( ).find ( ext::make_pair ( state, EpsilonType ( ) ) );
}
if ( callTransition != automaton.getCallTransitions ( ).end ( ) ) {
@@ -433,13 +433,13 @@ ext::tuple < bool, StateType, ext::set < unsigned >, ext::deque < PushdownStoreS
}
if ( !res ) {
- auto localTransition = automaton.getLocalTransitions ( ).find ( std::make_pair ( state, * symbolIter ) );
+ auto localTransition = automaton.getLocalTransitions ( ).find ( ext::make_pair ( state, * symbolIter ) );
if ( localTransition != automaton.getLocalTransitions ( ).end ( ) ) {
symbolIter++;
i++;
} else {
- localTransition = automaton.getLocalTransitions ( ).find ( std::make_pair ( state, EpsilonType ( ) ) );
+ localTransition = automaton.getLocalTransitions ( ).find ( ext::make_pair ( state, EpsilonType ( ) ) );
}
if ( localTransition != automaton.getLocalTransitions ( ).end ( ) )
@@ -497,7 +497,7 @@ ext::tuple < bool, StateType, ext::set < unsigned >, ext::deque < PushdownStoreS
}
if ( common::GlobalData::verbose )
- std::clog << "Transition: " << * transition << std::endl;
+ std::clog << "Transition: " << transition->first << " to " << transition->second << std::endl;
for ( unsigned j = 0; j < std::get < 2 > ( transition->first ).size ( ); j++ ) pushdownStore.pop_back ( );
diff --git a/alib2algo/src/automaton/simplify/EpsilonRemoverIncoming.h b/alib2algo/src/automaton/simplify/EpsilonRemoverIncoming.h
index f6b81f441fc64351d568571af676f08fa74c9d7c..4c7dd04f6f1d8f1b82cccdb15149f2c31dd2baa4 100644
--- a/alib2algo/src/automaton/simplify/EpsilonRemoverIncoming.h
+++ b/alib2algo/src/automaton/simplify/EpsilonRemoverIncoming.h
@@ -62,7 +62,7 @@ automaton::NFA < SymbolType, StateType > EpsilonRemoverIncoming::remove( const a
fsm.setStates( origFSM.getStates() );
fsm.setInputAlphabet( origFSM.getInputAlphabet() );
- ext::map<std::pair<StateType, SymbolType>, ext::set<StateType>> origTransitions = origFSM.getSymbolTransitions();
+ ext::map<ext::pair<StateType, SymbolType>, ext::set<StateType>> origTransitions = origFSM.getSymbolTransitions();
/**
* Step 1 from Melichar 2.41
@@ -70,7 +70,7 @@ automaton::NFA < SymbolType, StateType > EpsilonRemoverIncoming::remove( const a
for( const auto & from : origFSM.getStates( ) )
for( const auto & fromClosure : automaton::properties::EpsilonClosure::epsilonClosure( origFSM, from ) )
for( const auto & symbol : origFSM.getInputAlphabet() ) {
- auto transitions = origTransitions.find(std::make_pair(fromClosure, symbol));
+ auto transitions = origTransitions.find(ext::make_pair(fromClosure, symbol));
if(transitions == origTransitions.end()) continue;
for( const auto & to : transitions->second )
diff --git a/alib2algo/src/automaton/simplify/Total.h b/alib2algo/src/automaton/simplify/Total.h
index 35ee30c068220a31b836c856e059b55002e54fe3..3b16f3518314fc528e50d31585473100c9cd8ab4 100644
--- a/alib2algo/src/automaton/simplify/Total.h
+++ b/alib2algo/src/automaton/simplify/Total.h
@@ -53,7 +53,7 @@ automaton::NFA < SymbolType, StateType > Total::total(const automaton::NFA < Sym
for(const auto& q : res.getStates()) {
for(const auto& a : res.getInputAlphabet()) {
- if(res.getTransitions().find(std::make_pair(q, a)) == res.getTransitions().end()) {
+ if(res.getTransitions().find(ext::make_pair(q, a)) == res.getTransitions().end()) {
res.addTransition(q, a, nullState);
}
}
@@ -70,7 +70,7 @@ automaton::DFA < SymbolType, StateType > Total::total(const automaton::DFA < Sym
for(const auto& q : res.getStates()) {
for(const auto& a : res.getInputAlphabet()) {
- if(res.getTransitions().find(std::make_pair(q, a)) == res.getTransitions().end()) {
+ if(res.getTransitions().find(ext::make_pair(q, a)) == res.getTransitions().end()) {
res.addTransition(q, a, nullState);
}
}
diff --git a/alib2algo/src/automaton/simplify/UnreachableStatesRemover.h b/alib2algo/src/automaton/simplify/UnreachableStatesRemover.h
index 2c276248ccbd2dfd638d663ebcad3eb3477b8d8c..482b0bdf859e46041a14fdc3d1dd81bf706e2055 100644
--- a/alib2algo/src/automaton/simplify/UnreachableStatesRemover.h
+++ b/alib2algo/src/automaton/simplify/UnreachableStatesRemover.h
@@ -129,12 +129,12 @@ automaton::DFTA < SymbolType, RankType, StateType > UnreachableStatesRemover::re
automaton::DFTA < SymbolType, RankType, StateType > res;
res.setInputAlphabet(dfta.getInputAlphabet());
- typedef std::pair < const std::pair < common::ranked_symbol < SymbolType, RankType >, ext::vector < StateType > >, StateType > Transition;
- ext::vector<std::pair<const Transition *, int>> transitionsUnreachableCount;
+ typedef std::pair < const ext::pair < common::ranked_symbol < SymbolType, RankType >, ext::vector < StateType > >, StateType > Transition;
+ ext::vector<ext::pair<const Transition *, int>> transitionsUnreachableCount;
transitionsUnreachableCount.reserve(dfta.getTransitions().size());
//for a state, transitions with unreachable count (initially all unreachable) and number of occurences of this state (at least 1)
- ext::map<StateType, ext::map<std::pair<const Transition *, int> *, int>> stateOccurences;
+ ext::map<StateType, ext::map<ext::pair<const Transition *, int> *, int>> stateOccurences;
ext::deque<StateType> queue;
for(const auto & transition : dfta.getTransitions()) {
if (transition.first.second.empty()) {
diff --git a/alib2algo/src/automaton/simplify/UselessStatesRemover.h b/alib2algo/src/automaton/simplify/UselessStatesRemover.h
index f51471fcac29bfdf56274aba241e17d81d8a7538..2d99bee19e552ad891a865da106da3e18cd42d6c 100644
--- a/alib2algo/src/automaton/simplify/UselessStatesRemover.h
+++ b/alib2algo/src/automaton/simplify/UselessStatesRemover.h
@@ -140,7 +140,7 @@ automaton::DFTA < SymbolType, RankType, StateType > UselessStatesRemover::remove
res.setStates(dfta.getFinalStates());
res.setFinalStates(dfta.getFinalStates());
- typedef std::pair < const std::pair < common::ranked_symbol < SymbolType, RankType >, ext::vector < StateType > >, StateType > Transition;
+ typedef std::pair < const ext::pair < common::ranked_symbol < SymbolType, RankType >, ext::vector < StateType > >, StateType > Transition;
ext::map<StateType, ext::set<const Transition *>> transitionsToState;
for(const auto & transition : dfta.getTransitions()) {
diff --git a/alib2algo/src/automaton/transform/AutomataIntersectionCartesianProduct.cpp b/alib2algo/src/automaton/transform/AutomataIntersectionCartesianProduct.cpp
index f5feba0822c7926cb53e6259894c84634ea59534..578acfce4c27e91ff9d3de352c6866b71fc78337 100644
--- a/alib2algo/src/automaton/transform/AutomataIntersectionCartesianProduct.cpp
+++ b/alib2algo/src/automaton/transform/AutomataIntersectionCartesianProduct.cpp
@@ -19,8 +19,8 @@ automaton::Automaton AutomataIntersectionCartesianProduct::intersection(const au
return res;
}
-auto AutomataIntersectionCartesianProductDFA = registration::OverloadRegister < AutomataIntersectionCartesianProduct, automaton::DFA < DefaultSymbolType, std::pair < DefaultStateType, DefaultStateType > >, automaton::DFA < > > ( AutomataIntersectionCartesianProduct::intersection );
-auto AutomataIntersectionCartesianProductNFA = registration::OverloadRegister < AutomataIntersectionCartesianProduct, automaton::NFA < DefaultSymbolType, std::pair < DefaultStateType, DefaultStateType > >, automaton::NFA < > > ( AutomataIntersectionCartesianProduct::intersection );
+auto AutomataIntersectionCartesianProductDFA = registration::OverloadRegister < AutomataIntersectionCartesianProduct, automaton::DFA < DefaultSymbolType, ext::pair < DefaultStateType, DefaultStateType > >, automaton::DFA < > > ( AutomataIntersectionCartesianProduct::intersection );
+auto AutomataIntersectionCartesianProductNFA = registration::OverloadRegister < AutomataIntersectionCartesianProduct, automaton::NFA < DefaultSymbolType, ext::pair < DefaultStateType, DefaultStateType > >, automaton::NFA < > > ( AutomataIntersectionCartesianProduct::intersection );
} /* namespace transform */
diff --git a/alib2algo/src/automaton/transform/AutomataIntersectionCartesianProduct.h b/alib2algo/src/automaton/transform/AutomataIntersectionCartesianProduct.h
index 8855a5d946a8687100ba405830697eb7aba8f1f7..b3b607811c39db1ca4cf1f71a437c7f94c4abd48 100644
--- a/alib2algo/src/automaton/transform/AutomataIntersectionCartesianProduct.h
+++ b/alib2algo/src/automaton/transform/AutomataIntersectionCartesianProduct.h
@@ -25,15 +25,15 @@ public:
static automaton::Automaton intersection(const automaton::Automaton& first, const automaton::Automaton& second);
template < class SymbolType, class StateType1, class StateType2 >
- static automaton::NFA < SymbolType, std::pair < StateType1, StateType2 > > intersection(const automaton::NFA < SymbolType, StateType1 > & first, const automaton::NFA < SymbolType, StateType2 > & second);
+ static automaton::NFA < SymbolType, ext::pair < StateType1, StateType2 > > intersection(const automaton::NFA < SymbolType, StateType1 > & first, const automaton::NFA < SymbolType, StateType2 > & second);
template < class SymbolType, class StateType1, class StateType2 >
- static automaton::DFA < SymbolType, std::pair < StateType1, StateType2 > > intersection(const automaton::DFA < SymbolType, StateType1 > & first, const automaton::DFA < SymbolType, StateType2 > & second);
+ static automaton::DFA < SymbolType, ext::pair < StateType1, StateType2 > > intersection(const automaton::DFA < SymbolType, StateType1 > & first, const automaton::DFA < SymbolType, StateType2 > & second);
};
template < class SymbolType, class StateType1, class StateType2 >
-automaton::DFA < SymbolType, std::pair < StateType1, StateType2 > > AutomataIntersectionCartesianProduct::intersection(const automaton::DFA < SymbolType, StateType1 > & first, const automaton::DFA < SymbolType, StateType2 > & second) {
- std::pair < StateType1, StateType2 > q0 ( first.getInitialState ( ), second.getInitialState ( ) );
- automaton::DFA < SymbolType, std::pair < StateType1, StateType2 > > res(q0);
+automaton::DFA < SymbolType, ext::pair < StateType1, StateType2 > > AutomataIntersectionCartesianProduct::intersection(const automaton::DFA < SymbolType, StateType1 > & first, const automaton::DFA < SymbolType, StateType2 > & second) {
+ ext::pair < StateType1, StateType2 > q0 ( first.getInitialState ( ), second.getInitialState ( ) );
+ automaton::DFA < SymbolType, ext::pair < StateType1, StateType2 > > res(q0);
for(const auto& a : first.getInputAlphabet())
res.addInputSymbol(a);
@@ -42,25 +42,25 @@ automaton::DFA < SymbolType, std::pair < StateType1, StateType2 > > AutomataInte
for(const auto& p : first.getStates())
for(const auto& q : second.getStates())
- res.addState ( std::make_pair ( p, q ) );
+ res.addState ( ext::make_pair ( p, q ) );
for(const auto& p : first.getFinalStates())
for(const auto& q : second.getFinalStates())
- res.addFinalState ( std::make_pair ( p, q ) );
+ res.addFinalState ( ext::make_pair ( p, q ) );
- for(const std::pair < StateType1, StateType2 > & state : res.getStates ( ) )
+ for(const ext::pair < StateType1, StateType2 > & state : res.getStates ( ) )
for(const auto & tp : first.getTransitionsFromState ( state.first ) )
for(const auto & tq : second.getTransitionsFromState ( state.second ) )
if(tp.first.second == tq.first.second)
- res.addTransition ( state, tp.first.second, std::make_pair ( tp.second, tq.second ) );
+ res.addTransition ( state, tp.first.second, ext::make_pair ( tp.second, tq.second ) );
return res;
}
template < class SymbolType, class StateType1, class StateType2 >
-automaton::NFA < SymbolType, std::pair < StateType1, StateType2 > > AutomataIntersectionCartesianProduct::intersection(const automaton::NFA < SymbolType, StateType1 > & first, const automaton::NFA < SymbolType, StateType2 > & second) {
- std::pair < StateType1, StateType2 > q0 ( first.getInitialState ( ), second.getInitialState ( ) );
- automaton::NFA < SymbolType, std::pair < StateType1, StateType2 > > res ( q0 );
+automaton::NFA < SymbolType, ext::pair < StateType1, StateType2 > > AutomataIntersectionCartesianProduct::intersection(const automaton::NFA < SymbolType, StateType1 > & first, const automaton::NFA < SymbolType, StateType2 > & second) {
+ ext::pair < StateType1, StateType2 > q0 ( first.getInitialState ( ), second.getInitialState ( ) );
+ automaton::NFA < SymbolType, ext::pair < StateType1, StateType2 > > res ( q0 );
for(const auto& a : first.getInputAlphabet())
res.addInputSymbol(a);
@@ -69,19 +69,19 @@ automaton::NFA < SymbolType, std::pair < StateType1, StateType2 > > AutomataInte
for(const auto& p : first.getStates())
for(const auto& q : second.getStates())
- res.addState ( std::make_pair ( p, q ) );
+ res.addState ( ext::make_pair ( p, q ) );
for(const auto& p : first.getFinalStates())
for(const auto& q : second.getFinalStates())
- res.addFinalState ( std::make_pair ( p, q ) );
+ res.addFinalState ( ext::make_pair ( p, q ) );
- for(const std::pair < StateType1, StateType2 > & state : res.getStates ( ) )
+ for(const ext::pair < StateType1, StateType2 > & state : res.getStates ( ) )
for(const auto & tp : first.getTransitionsFromState ( state.first ) )
for(const auto & tq : second.getTransitionsFromState ( state.second ) )
if(tp.first.second == tq.first.second)
for(const auto & p : tp.second)
for(const auto & q : tq.second)
- res.addTransition ( state, tp.first.second, std::make_pair ( p, q ) );
+ res.addTransition ( state, tp.first.second, ext::make_pair ( p, q ) );
return res;
}
diff --git a/alib2algo/src/automaton/transform/AutomataUnionCartesianProduct.cpp b/alib2algo/src/automaton/transform/AutomataUnionCartesianProduct.cpp
index 901d836686814b3e0f7af2bced291032cd62d54e..aa04de57db6a282dd397438b0c00e513e63c6140 100644
--- a/alib2algo/src/automaton/transform/AutomataUnionCartesianProduct.cpp
+++ b/alib2algo/src/automaton/transform/AutomataUnionCartesianProduct.cpp
@@ -20,8 +20,8 @@ automaton::Automaton AutomataUnionCartesianProduct::unification(const automaton:
return res;
}
-auto AutomataUnionCartesianProductDFA = registration::OverloadRegister < AutomataUnionCartesianProduct, automaton::DFA < DefaultSymbolType, std::pair < DefaultStateType, DefaultStateType > >, automaton::DFA < > > ( AutomataUnionCartesianProduct::unification );
-auto AutomataUnionCartesianProductNFA = registration::OverloadRegister < AutomataUnionCartesianProduct, automaton::NFA < DefaultSymbolType, std::pair < DefaultStateType, DefaultStateType > >, automaton::NFA < > > ( AutomataUnionCartesianProduct::unification );
+auto AutomataUnionCartesianProductDFA = registration::OverloadRegister < AutomataUnionCartesianProduct, automaton::DFA < DefaultSymbolType, ext::pair < DefaultStateType, DefaultStateType > >, automaton::DFA < > > ( AutomataUnionCartesianProduct::unification );
+auto AutomataUnionCartesianProductNFA = registration::OverloadRegister < AutomataUnionCartesianProduct, automaton::NFA < DefaultSymbolType, ext::pair < DefaultStateType, DefaultStateType > >, automaton::NFA < > > ( AutomataUnionCartesianProduct::unification );
} /* namespace transform */
diff --git a/alib2algo/src/automaton/transform/AutomataUnionCartesianProduct.h b/alib2algo/src/automaton/transform/AutomataUnionCartesianProduct.h
index 45c118370dc8d75b27fe379cb99a8d7eeb30ceb0..a5d44f87d82e0a857b937adc719ad9d78d273587 100644
--- a/alib2algo/src/automaton/transform/AutomataUnionCartesianProduct.h
+++ b/alib2algo/src/automaton/transform/AutomataUnionCartesianProduct.h
@@ -25,18 +25,18 @@ public:
static automaton::Automaton unification(const automaton::Automaton& first, const automaton::Automaton& second);
template < class SymbolType, class StateType1, class StateType2 >
- static automaton::NFA < SymbolType, std::pair < StateType1, StateType2 > > unification(const automaton::NFA < SymbolType, StateType1 > & first, const automaton::NFA < SymbolType, StateType2 > & second);
+ static automaton::NFA < SymbolType, ext::pair < StateType1, StateType2 > > unification(const automaton::NFA < SymbolType, StateType1 > & first, const automaton::NFA < SymbolType, StateType2 > & second);
template < class SymbolType, class StateType1, class StateType2 >
- static automaton::DFA < SymbolType, std::pair < StateType1, StateType2 > > unification(const automaton::DFA < SymbolType, StateType1 > & first, const automaton::DFA < SymbolType, StateType2 > & second);
+ static automaton::DFA < SymbolType, ext::pair < StateType1, StateType2 > > unification(const automaton::DFA < SymbolType, StateType1 > & first, const automaton::DFA < SymbolType, StateType2 > & second);
};
template < class SymbolType, class StateType1, class StateType2 >
-automaton::DFA < SymbolType, std::pair < StateType1, StateType2 > > AutomataUnionCartesianProduct::unification(const automaton::DFA < SymbolType, StateType1 > & first, const automaton::DFA < SymbolType, StateType2 > & second) {
+automaton::DFA < SymbolType, ext::pair < StateType1, StateType2 > > AutomataUnionCartesianProduct::unification(const automaton::DFA < SymbolType, StateType1 > & first, const automaton::DFA < SymbolType, StateType2 > & second) {
if(!first.isTotal() || !second.isTotal())
throw exception::CommonException("Automata must be total to unify with cartesian product");
- std::pair < StateType1, StateType2 > q0 ( first.getInitialState(), second.getInitialState() );
- automaton::DFA < SymbolType, std::pair < StateType1, StateType2 > > res ( q0 );
+ ext::pair < StateType1, StateType2 > q0 ( first.getInitialState(), second.getInitialState() );
+ automaton::DFA < SymbolType, ext::pair < StateType1, StateType2 > > res ( q0 );
for(const auto& a : first.getInputAlphabet())
res.addInputSymbol(a);
@@ -45,33 +45,33 @@ automaton::DFA < SymbolType, std::pair < StateType1, StateType2 > > AutomataUnio
for(const auto& p : first.getStates())
for(const auto& q : second.getStates())
- res.addState(std::make_pair(p, q));
+ res.addState(ext::make_pair(p, q));
for(const auto& p : first.getFinalStates())
for(const auto& q : second.getStates())
- res.addFinalState(std::make_pair(p, q));
+ res.addFinalState(ext::make_pair(p, q));
for(const auto& p : first.getStates())
for(const auto& q : second.getFinalStates())
- res.addFinalState(std::make_pair(p, q));
+ res.addFinalState(ext::make_pair(p, q));
for(const auto& state : res.getStates())
for(const auto& tp : first.getTransitionsFromState(state.first))
for(const auto& tq : second.getTransitionsFromState(state.second))
if(tp.first.second == tq.first.second)
- res.addTransition(state, tp.first.second, std::make_pair(tp.second, tq.second));
+ res.addTransition(state, tp.first.second, ext::make_pair(tp.second, tq.second));
return res;
}
template < class SymbolType, class StateType1, class StateType2 >
-automaton::NFA < SymbolType, std::pair < StateType1, StateType2 > > AutomataUnionCartesianProduct::unification(const automaton::NFA < SymbolType, StateType1 > & first, const automaton::NFA < SymbolType, StateType2 > & second) {
+automaton::NFA < SymbolType, ext::pair < StateType1, StateType2 > > AutomataUnionCartesianProduct::unification(const automaton::NFA < SymbolType, StateType1 > & first, const automaton::NFA < SymbolType, StateType2 > & second) {
if(!first.isTotal() || !second.isTotal())
throw exception::CommonException("Automata must be total to unify with cartesian product");
- std::pair < StateType1, StateType2 > q0 ( first.getInitialState(), second.getInitialState() );
- automaton::NFA < SymbolType, std::pair < StateType1, StateType2 > > res(q0);
+ ext::pair < StateType1, StateType2 > q0 ( first.getInitialState(), second.getInitialState() );
+ automaton::NFA < SymbolType, ext::pair < StateType1, StateType2 > > res(q0);
for(const auto& a : first.getInputAlphabet())
res.addInputSymbol(a);
@@ -80,15 +80,15 @@ automaton::NFA < SymbolType, std::pair < StateType1, StateType2 > > AutomataUnio
for(const auto& p : first.getStates())
for(const auto& q : second.getStates())
- res.addState(std::make_pair(p, q));
+ res.addState(ext::make_pair(p, q));
for(const auto& p : first.getFinalStates())
for(const auto& q : second.getStates())
- res.addFinalState(std::make_pair(p, q));
+ res.addFinalState(ext::make_pair(p, q));
for(const auto& p : first.getStates())
for(const auto& q : second.getFinalStates())
- res.addFinalState(std::make_pair(p, q));
+ res.addFinalState(ext::make_pair(p, q));
for(const auto& state : res.getStates())
for(const auto& tp : first.getTransitionsFromState(state.first))
@@ -96,7 +96,7 @@ automaton::NFA < SymbolType, std::pair < StateType1, StateType2 > > AutomataUnio
if(tp.first.second == tq.first.second)
for(const auto& p : tp.second)
for(const auto& q : tq.second)
- res.addTransition(state, tp.first.second, std::make_pair(p, q));
+ res.addTransition(state, tp.first.second, ext::make_pair(p, q));
return res;
}
diff --git a/alib2algo/src/automaton/transform/Compaction.h b/alib2algo/src/automaton/transform/Compaction.h
index 93f00779241e1a3870c78f174a76d46df1a1f2fb..1e299bd6970b2eb0a5ed07e659221ebcd2a8685f 100644
--- a/alib2algo/src/automaton/transform/Compaction.h
+++ b/alib2algo/src/automaton/transform/Compaction.h
@@ -69,10 +69,10 @@ automaton::CompactNFA < SymbolType, StateType > Compaction::convert(const automa
ext::vector < SymbolType > path { symbol };
- ext::range < typename ext::map < std::pair < StateType, SymbolType >, StateType >::const_iterator > transitions;
+ ext::range < typename ext::map < ext::pair < StateType, SymbolType >, StateType >::const_iterator > transitions;
// only 1 child and nonfinal
while((transitions = automaton.getTransitionsFromState(q)).size() == 1 && automaton.getFinalStates().count(q) == 0) {
- const std::pair<std::pair<StateType, SymbolType>, StateType>& transition = * transitions.begin();
+ const std::pair<ext::pair<StateType, SymbolType>, StateType>& transition = * transitions.begin();
path.push_back(transition.first.second);
q = transition.second;
}
@@ -85,7 +85,7 @@ automaton::CompactNFA < SymbolType, StateType > Compaction::convert(const automa
res.addTransition(lastFork, path, q);
- for(const std::pair<const std::pair<StateType, SymbolType>, StateType>& transition : automaton.getTransitionsFromState(q))
+ for(const std::pair<const ext::pair<StateType, SymbolType>, StateType>& transition : automaton.getTransitionsFromState(q))
if(visited.insert(transition.second).second)
stack.push(ext::make_tuple(transition.second, q, transition.first.second));
diff --git a/alib2algo/src/grammar/convert/ToAutomaton.cpp b/alib2algo/src/grammar/convert/ToAutomaton.cpp
index a4e335f234349c1d40f057aaff5a2a77228ed483..fe393a9bbd5485c8954d628f1b85f85a594becf1 100644
--- a/alib2algo/src/grammar/convert/ToAutomaton.cpp
+++ b/alib2algo/src/grammar/convert/ToAutomaton.cpp
@@ -42,8 +42,8 @@ automaton::NFA < > ToAutomaton::convert(const grammar::LeftRG < > & grammar) {
for(const auto& rule : grammar.getRules()) {
const DefaultSymbolType& lhs = rule.first;
for(const auto& ruleRHS : rule.second) {
- if(ruleRHS.is<std::pair<DefaultSymbolType, DefaultSymbolType>>()) { // if B->Ca => \delta(C,a)=B
- const std::pair<DefaultSymbolType, DefaultSymbolType>& rhs = ruleRHS.get<std::pair<DefaultSymbolType, DefaultSymbolType>>();
+ if(ruleRHS.is<ext::pair<DefaultSymbolType, DefaultSymbolType>>()) { // if B->Ca => \delta(C,a)=B
+ const ext::pair<DefaultSymbolType, DefaultSymbolType>& rhs = ruleRHS.get<ext::pair<DefaultSymbolType, DefaultSymbolType>>();
automaton.addTransition(stateMap.find(rhs.first)->second, rhs.second, stateMap.find(lhs)->second);
}
else { // if B->a => \delta(StartState,a)=B
@@ -86,8 +86,8 @@ automaton::NFA < > ToAutomaton::convert(const grammar::RightRG < > & grammar) {
for(const auto& rule : grammar.getRules()) {
const DefaultSymbolType& lhs = rule.first;
for(const auto& ruleRHS : rule.second) {
- if(ruleRHS.is<std::pair<DefaultSymbolType, DefaultSymbolType>>()) { // if B->aC => \delta(B,a)=C
- const std::pair<DefaultSymbolType, DefaultSymbolType>& rhs = ruleRHS.get<std::pair<DefaultSymbolType, DefaultSymbolType>>();
+ if(ruleRHS.is<ext::pair<DefaultSymbolType, DefaultSymbolType>>()) { // if B->aC => \delta(B,a)=C
+ const ext::pair<DefaultSymbolType, DefaultSymbolType>& rhs = ruleRHS.get<ext::pair<DefaultSymbolType, DefaultSymbolType>>();
automaton.addTransition(stateMap.find(lhs)->second, rhs.first, stateMap.find(rhs.second)->second);
}
else { // if B->a => \delta(B,a)=AState
diff --git a/alib2algo/src/grammar/convert/ToGrammarLeftRG.h b/alib2algo/src/grammar/convert/ToGrammarLeftRG.h
index 276fad882313d91a3acf3f5b31da81d077109660..ba052c78f5ad5e3654cf52f45019145d0616f818 100644
--- a/alib2algo/src/grammar/convert/ToGrammarLeftRG.h
+++ b/alib2algo/src/grammar/convert/ToGrammarLeftRG.h
@@ -55,29 +55,29 @@ grammar::LeftRG < SymbolType > ToGrammarLeftRG::convert(const grammar::RightRG <
const SymbolType& lhs = rule.first;
for(const auto & ruleRHS : rule.second ) {
- if( ruleRHS.template is<std::pair<SymbolType, SymbolType>>( ) ) {
- const std::pair<SymbolType, SymbolType>& rhs = ruleRHS.template get<std::pair<SymbolType, SymbolType>>();
+ if( ruleRHS.template is<ext::pair<SymbolType, SymbolType>>( ) ) {
+ const ext::pair<SymbolType, SymbolType>& rhs = ruleRHS.template get<ext::pair<SymbolType, SymbolType>>();
SymbolType leftSide = rhs.second;
- std::pair<SymbolType, SymbolType> rightSide = std::make_pair( lhs, rhs.first );
- lrg.addRule( leftSide, rightSide );
+ ext::pair<SymbolType, SymbolType> rightSide = ext::make_pair( lhs, rhs.first );
+ lrg.addRule( leftSide, std::move ( rightSide ) );
if( lhs == grammar.getInitialSymbol( ) ) {
leftSide = rhs.second;
SymbolType rightSide2 = rhs.first;
- lrg.addRule( leftSide, rightSide2 );
+ lrg.addRule( leftSide, std::move ( rightSide2 ) );
}
} else {
const SymbolType& rhs = ruleRHS.template get<SymbolType>();
SymbolType leftSide = lrg.getInitialSymbol( );
- std::pair<SymbolType, SymbolType> rightSide = std::make_pair ( lhs, rhs );
- lrg.addRule( leftSide, rightSide );
+ ext::pair<SymbolType, SymbolType> rightSide = ext::make_pair ( lhs, rhs );
+ lrg.addRule( leftSide, std::move ( rightSide ) );
if( lhs == grammar.getInitialSymbol( ) ) {
leftSide = lrg.getInitialSymbol( );
SymbolType rightSide2 = rhs;
- lrg.addRule( leftSide, rightSide2 );
+ lrg.addRule( leftSide, std::move ( rightSide2 ) );
}
}
}
diff --git a/alib2algo/src/grammar/convert/ToGrammarRightRG.h b/alib2algo/src/grammar/convert/ToGrammarRightRG.h
index 672f93e67526dba2241d9d34f9c96bcfc2c06b84..c6882bb8bd3fc5876a17dacb37e5ad5d0243280d 100644
--- a/alib2algo/src/grammar/convert/ToGrammarRightRG.h
+++ b/alib2algo/src/grammar/convert/ToGrammarRightRG.h
@@ -55,12 +55,12 @@ grammar::RightRG < SymbolType > ToGrammarRightRG::convert(const grammar::LeftRG
const SymbolType& lhs = rule.first;
for(const auto & ruleRHS : rule.second ) {
- if( ruleRHS.template is<std::pair<SymbolType, SymbolType>>( ) ) {
- const std::pair<SymbolType, SymbolType>& rhs = ruleRHS.template get<std::pair<SymbolType, SymbolType>>();
+ if( ruleRHS.template is<ext::pair<SymbolType, SymbolType>>( ) ) {
+ const ext::pair<SymbolType, SymbolType>& rhs = ruleRHS.template get<ext::pair<SymbolType, SymbolType>>();
SymbolType leftSide = ( rhs.first );
- std::pair<SymbolType, SymbolType> rightSide = std::make_pair( rhs.second, lhs );
- rrg.addRule( leftSide, rightSide );
+ ext::pair<SymbolType, SymbolType> rightSide = ext::make_pair( rhs.second, lhs );
+ rrg.addRule( leftSide, std::move ( rightSide ) );
if( lhs == grammar.getInitialSymbol( ) ) {
leftSide = rhs.first;
@@ -71,8 +71,8 @@ grammar::RightRG < SymbolType > ToGrammarRightRG::convert(const grammar::LeftRG
const SymbolType& rhs = ruleRHS.template get<SymbolType>();
SymbolType leftSide = rrg.getInitialSymbol( );
- std::pair<SymbolType, SymbolType> rightSide = std::make_pair( rhs, lhs );
- rrg.addRule( leftSide, rightSide );
+ ext::pair<SymbolType, SymbolType> rightSide = ext::make_pair( rhs, lhs );
+ rrg.addRule( leftSide, std::move ( rightSide ) );
if( lhs == grammar.getInitialSymbol( ) ) {
leftSide = rrg.getInitialSymbol( );
diff --git a/alib2algo/src/grammar/convert/ToRegExpAlgebraic.h b/alib2algo/src/grammar/convert/ToRegExpAlgebraic.h
index 5d68ae797fc48d9473585dd5c2e91a1811008e91..b8a59b94f3603ae81fe51f903dee47620b023d18 100644
--- a/alib2algo/src/grammar/convert/ToRegExpAlgebraic.h
+++ b/alib2algo/src/grammar/convert/ToRegExpAlgebraic.h
@@ -55,7 +55,7 @@ regexp::UnboundedRegExp < SymbolType > ToRegExpAlgebraic::convert(const grammar:
const SymbolType& rhs = ruleRHS.template get<SymbolType>();
solver.addEquation(lhs, regexp::UnboundedRegExpSymbol < SymbolType > (rhs));
} else {
- const std::pair<SymbolType, SymbolType>& rhs = ruleRHS.template get<std::pair<SymbolType, SymbolType>>();
+ const ext::pair<SymbolType, SymbolType>& rhs = ruleRHS.template get<ext::pair<SymbolType, SymbolType>>();
solver.addEquation(lhs, rhs.first, regexp::UnboundedRegExpSymbol < SymbolType > (rhs.second));
}
}
@@ -81,7 +81,7 @@ regexp::UnboundedRegExp < SymbolType > ToRegExpAlgebraic::convert(const grammar:
const SymbolType& rhs = ruleRHS.template get<SymbolType>();
solver.addEquation(lhs, regexp::UnboundedRegExpSymbol < SymbolType > (rhs));
} else {
- const std::pair<SymbolType, SymbolType>& rhs = ruleRHS.template get<std::pair<SymbolType, SymbolType>>();
+ const ext::pair<SymbolType, SymbolType>& rhs = ruleRHS.template get<ext::pair<SymbolType, SymbolType>>();
solver.addEquation(lhs, rhs.second, regexp::UnboundedRegExpSymbol < SymbolType > (rhs.first));
}
}
diff --git a/alib2algo/src/grammar/generate/CockeYoungerKasami.h b/alib2algo/src/grammar/generate/CockeYoungerKasami.h
index 1ee51c170a6223081cff528bda03cabd09428588..dd708881fdbdaf151367d2d4fd93acdc8304c65a 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, ext::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > rule : grammar.getRules ( ) ) {
+ for ( const std::pair < const SymbolType, ext::set < ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > > > rule : grammar.getRules ( ) ) {
const SymbolType & lhs = rule.first;
- for ( const ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs : rule.second )
+ for ( const ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > rhs : rule.second )
if ( rhs.template is < SymbolType > ( ) && ( rhs.template get < SymbolType > ( ) == string.getContent ( )[i] ) )
data[0][i].insert ( lhs );
@@ -64,12 +64,12 @@ bool CockeYoungerKasami::generate ( const grammar::CNF < SymbolType > & grammar,
for ( const SymbolType & verticalElement : vertical ) {
for ( const SymbolType & diagonalElement : diagonal )
- for ( const std::pair < const SymbolType, ext::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > rule : grammar.getRules ( ) ) {
+ for ( const std::pair < const SymbolType, ext::set < ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > > > rule : grammar.getRules ( ) ) {
const SymbolType & lhs = rule.first;
- 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 > > ( );
+ for ( const ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > rhs : rule.second )
+ if ( rhs.template is < ext::pair < SymbolType, SymbolType > > ( ) ) {
+ const ext::pair < SymbolType, SymbolType > rhsp = rhs.template get < ext::pair < SymbolType, SymbolType > > ( );
if ( ( rhsp.first == verticalElement ) && ( rhsp.second == diagonalElement ) )
targetCell.insert ( lhs );
diff --git a/alib2algo/src/grammar/generate/RandomizeGrammar.h b/alib2algo/src/grammar/generate/RandomizeGrammar.h
index 7b8c580b8600b8b26dc57832d7b827361bfb39ec..f963347ed66ebf553946aec3c1329282e0c84bf3 100644
--- a/alib2algo/src/grammar/generate/RandomizeGrammar.h
+++ b/alib2algo/src/grammar/generate/RandomizeGrammar.h
@@ -49,12 +49,12 @@ grammar::LeftRG < SymbolType > RandomizeGrammar::randomize ( const grammar::Left
res.setNonterminalAlphabet ( gram.getNonterminalAlphabet ( ) );
res.setTerminalAlphabet ( gram.getTerminalAlphabet ( ) );
- for ( const std::pair < SymbolType, ext::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & rule : gram.getRules ( ) )
- for ( const ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rhs : rule.second )
+ for ( const std::pair < SymbolType, ext::set < ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > > > & rule : gram.getRules ( ) )
+ for ( const ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > & rhs : rule.second )
if ( rhs.template is < SymbolType > ( ) )
res.addRule ( symbolPermutationMap.find ( rule.first )->second, rhs );
else
- res.addRule ( symbolPermutationMap.find ( rule.first )->second, std::make_pair ( symbolPermutationMap.find ( rhs.template get < std::pair < SymbolType, SymbolType > > ( ).first )->second, rhs.template get < std::pair < SymbolType, SymbolType > > ( ).second ) );
+ res.addRule ( symbolPermutationMap.find ( rule.first )->second, ext::make_pair ( symbolPermutationMap.find ( rhs.template get < ext::pair < SymbolType, SymbolType > > ( ).first )->second, rhs.template get < ext::pair < SymbolType, SymbolType > > ( ).second ) );
return res;
}
@@ -68,12 +68,12 @@ grammar::LeftLG < SymbolType > RandomizeGrammar::randomize ( const grammar::Left
res.setNonterminalAlphabet ( gram.getNonterminalAlphabet ( ) );
res.setTerminalAlphabet ( gram.getTerminalAlphabet ( ) );
- for ( const std::pair < SymbolType, ext::set < ext::variant < ext::vector < SymbolType >, std::pair < SymbolType, ext::vector < SymbolType > > > > > & rule : gram.getRules ( ) )
- for ( const ext::variant < ext::vector < SymbolType >, std::pair < SymbolType, ext::vector < SymbolType > > > & rhs : rule.second )
+ for ( const std::pair < SymbolType, ext::set < ext::variant < ext::vector < SymbolType >, ext::pair < SymbolType, ext::vector < SymbolType > > > > > & rule : gram.getRules ( ) )
+ for ( const ext::variant < ext::vector < SymbolType >, ext::pair < SymbolType, ext::vector < SymbolType > > > & rhs : rule.second )
if ( rhs.template is < ext::vector < SymbolType > > ( ) )
res.addRule ( symbolPermutationMap.find ( rule.first )->second, rhs );
else
- res.addRule ( symbolPermutationMap.find ( rule.first )->second, std::make_pair ( symbolPermutationMap.find ( rhs.template get < std::pair < SymbolType, ext::vector < SymbolType > > > ( ).first )->second, rhs.template get < std::pair < SymbolType, ext::vector < SymbolType > > > ( ).second ) );
+ res.addRule ( symbolPermutationMap.find ( rule.first )->second, ext::make_pair ( symbolPermutationMap.find ( rhs.template get < ext::pair < SymbolType, ext::vector < SymbolType > > > ( ).first )->second, rhs.template get < ext::pair < SymbolType, ext::vector < SymbolType > > > ( ).second ) );
return res;
}
@@ -87,12 +87,12 @@ grammar::RightRG < SymbolType > RandomizeGrammar::randomize ( const grammar::Rig
res.setNonterminalAlphabet ( gram.getNonterminalAlphabet ( ) );
res.setTerminalAlphabet ( gram.getTerminalAlphabet ( ) );
- for ( const std::pair < SymbolType, ext::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & rule : gram.getRules ( ) )
- for ( const ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rhs : rule.second )
+ for ( const std::pair < SymbolType, ext::set < ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > > > & rule : gram.getRules ( ) )
+ for ( const ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > & rhs : rule.second )
if ( rhs.template is < SymbolType > ( ) )
res.addRule ( symbolPermutationMap.find ( rule.first )->second, rhs );
else
- res.addRule ( symbolPermutationMap.find ( rule.first )->second, std::make_pair ( rhs.template get < std::pair < SymbolType, SymbolType > > ( ).first, symbolPermutationMap.find ( rhs.template get < std::pair < SymbolType, SymbolType > > ( ).second )->second ) );
+ res.addRule ( symbolPermutationMap.find ( rule.first )->second, ext::make_pair ( rhs.template get < ext::pair < SymbolType, SymbolType > > ( ).first, symbolPermutationMap.find ( rhs.template get < ext::pair < SymbolType, SymbolType > > ( ).second )->second ) );
return res;
}
@@ -106,12 +106,12 @@ grammar::RightLG < SymbolType > RandomizeGrammar::randomize ( const grammar::Rig
res.setNonterminalAlphabet ( gram.getNonterminalAlphabet ( ) );
res.setTerminalAlphabet ( gram.getTerminalAlphabet ( ) );
- for ( const std::pair < SymbolType, ext::set < ext::variant < ext::vector < SymbolType >, std::pair < ext::vector < SymbolType >, SymbolType > > > > & rule : gram.getRules ( ) )
- for ( const ext::variant < ext::vector < SymbolType >, std::pair < ext::vector < SymbolType >, SymbolType > > & rhs : rule.second )
+ for ( const std::pair < SymbolType, ext::set < ext::variant < ext::vector < SymbolType >, ext::pair < ext::vector < SymbolType >, SymbolType > > > > & rule : gram.getRules ( ) )
+ for ( const ext::variant < ext::vector < SymbolType >, ext::pair < ext::vector < SymbolType >, SymbolType > > & rhs : rule.second )
if ( rhs.template is < ext::vector < SymbolType > > ( ) )
res.addRule ( symbolPermutationMap.find ( rule.first )->second, rhs );
else
- res.addRule ( symbolPermutationMap.find ( rule.first )->second, std::make_pair ( rhs.template get < std::pair < ext::vector < SymbolType >, SymbolType > > ( ).first, symbolPermutationMap.find ( rhs.template get < std::pair < ext::vector < SymbolType >, SymbolType > > ( ).second )->second ) );
+ res.addRule ( symbolPermutationMap.find ( rule.first )->second, ext::make_pair ( rhs.template get < ext::pair < ext::vector < SymbolType >, SymbolType > > ( ).first, symbolPermutationMap.find ( rhs.template get < ext::pair < ext::vector < SymbolType >, SymbolType > > ( ).second )->second ) );
return res;
}
diff --git a/alib2algo/src/grammar/simplify/LeftRecursionRemover.h b/alib2algo/src/grammar/simplify/LeftRecursionRemover.h
index cb139ef74a08b381418806e3547af7403a79a7b3..b93496c53c5b696419f0df9455f064b4055ca0d6 100644
--- a/alib2algo/src/grammar/simplify/LeftRecursionRemover.h
+++ b/alib2algo/src/grammar/simplify/LeftRecursionRemover.h
@@ -127,9 +127,9 @@ grammar::EpsilonFreeCFG < SymbolType > LeftRecursionRemover::assignAsOrder(const
continue;
}
- const std::pair<SymbolType, ext::set<ext::vector<SymbolType>>>& rule = *origGrammar.getRules().find(lhs);
+ const ext::set<ext::vector<SymbolType>>& rule = origGrammar.getRules().find(lhs)->second;
- for(const ext::vector<SymbolType>& singleRHS : rule.second) {
+ for(const ext::vector<SymbolType>& singleRHS : rule) {
if(res.getTerminalAlphabet().count(singleRHS[0])) { //do not substitute terminals
res.addRule(lhs, singleRHS);
continue;
@@ -183,7 +183,7 @@ grammar::EpsilonFreeCFG < SymbolType > LeftRecursionRemover::remove(const gramma
if(rhs.template is<SymbolType>()) {
tmp.addRule(rule.first, {rhs.template get<SymbolType>()});
} else {
- const auto& rhsPair = rhs.template get<std::pair<SymbolType, SymbolType>>();
+ const auto& rhsPair = rhs.template get<ext::pair<SymbolType, SymbolType>>();
tmp.addRule(rule.first, {rhsPair.first, rhsPair.second});
}
}
diff --git a/alib2algo/src/grammar/simplify/ToCNF.cpp b/alib2algo/src/grammar/simplify/ToCNF.cpp
index 5149a0cdf5cf64ca5b79cb778bb10a98963583f7..35f4d123dd77fa408defb3c71f11e4452e0d88e5 100644
--- a/alib2algo/src/grammar/simplify/ToCNF.cpp
+++ b/alib2algo/src/grammar/simplify/ToCNF.cpp
@@ -19,9 +19,9 @@ namespace grammar {
namespace simplify {
template<class T>
-std::pair<DefaultSymbolType, DefaultSymbolType> splitToPairs(T& grammar, const ext::vector<DefaultSymbolType>& rhs, unsigned from, unsigned size, ext::map<DefaultSymbolType, DefaultSymbolType>& createdSymbols) {
+ext::pair<DefaultSymbolType, DefaultSymbolType> splitToPairs(T& grammar, const ext::vector<DefaultSymbolType>& rhs, unsigned from, unsigned size, ext::map<DefaultSymbolType, DefaultSymbolType>& createdSymbols) {
if(size == 2) {
- return std::make_pair(rhs[from], rhs[from + 1]);
+ return ext::make_pair(rhs[from], rhs[from + 1]);
} else if(size == 3) {
DefaultSymbolType firstLhs {rhs[from]};
@@ -33,7 +33,7 @@ std::pair<DefaultSymbolType, DefaultSymbolType> splitToPairs(T& grammar, const e
grammar.addNonterminalSymbol(createdSymbols.find(secondProposal)->second);
grammar.addRawRule(createdSymbols.find(secondProposal)->second, {std::move(second.first), std::move(second.second)});
- return std::make_pair(std::move(firstLhs), createdSymbols.find(secondProposal)->second);
+ return ext::make_pair(std::move(firstLhs), createdSymbols.find(secondProposal)->second);
} else {
auto first = splitToPairs(grammar, rhs, from, size / 2, createdSymbols);
DefaultSymbolType firstProposal{DefaultSymbolsPairType(first)};
@@ -51,7 +51,7 @@ std::pair<DefaultSymbolType, DefaultSymbolType> splitToPairs(T& grammar, const e
grammar.addNonterminalSymbol(createdSymbols.find(secondProposal)->second);
grammar.addRawRule(createdSymbols.find(secondProposal)->second, {std::move(second.first), std::move(second.second)});
- return std::make_pair(createdSymbols.find(firstProposal)->second, createdSymbols.find(secondProposal)->second);
+ return ext::make_pair(createdSymbols.find(firstProposal)->second, createdSymbols.find(secondProposal)->second);
}
}
diff --git a/alib2algo/src/grammar/simplify/ToGNF.h b/alib2algo/src/grammar/simplify/ToGNF.h
index a5c432d1ac647233c66a86958432a8a3b1ea0282..17159b32395a52aced65b424df8438854c87f20d 100644
--- a/alib2algo/src/grammar/simplify/ToGNF.h
+++ b/alib2algo/src/grammar/simplify/ToGNF.h
@@ -111,7 +111,7 @@ grammar::GNF < SymbolType > ToGNF::convertInternal( const grammar::EpsilonFreeCF
SymbolType primed = common::createUnique(terminal, res.getTerminalAlphabet(), res.getNonterminalAlphabet());
terminalToPrimed.insert(std::make_pair(terminal, primed));
res.addNonterminalSymbol(primed);
- res.addRule(primed, std::make_pair(terminal, ext::vector<SymbolType> {}));
+ res.addRule(primed, ext::make_pair(terminal, ext::vector<SymbolType> {}));
}
for(const auto& rule : step.getRules()) {
for(const auto& rhs : rule.second) {
@@ -128,7 +128,7 @@ grammar::GNF < SymbolType > ToGNF::convertInternal( const grammar::EpsilonFreeCF
else
convertedNonterminals.push_back(terminalToPrimed.find(rhsSymbol)->second);
}
- res.addRule(rule.first, std::make_pair(rhs[0], std::move(convertedNonterminals)));
+ res.addRule(rule.first, ext::make_pair(rhs[0], std::move(convertedNonterminals)));
}
}
return res;
diff --git a/alib2algo/src/regexp/convert/ToAutomatonGlushkov.cpp b/alib2algo/src/regexp/convert/ToAutomatonGlushkov.cpp
index 2b0f95fa1d831c0e74ee60ab876470a67ac745a1..e4fb3ec6f476ac89a95f3b707c68e3c4001ae677 100644
--- a/alib2algo/src/regexp/convert/ToAutomatonGlushkov.cpp
+++ b/alib2algo/src/regexp/convert/ToAutomatonGlushkov.cpp
@@ -30,39 +30,39 @@ automaton::NFA < > ToAutomatonGlushkov::convert ( const regexp::RegExp & regexp
}
automaton::NFA < > ToAutomatonGlushkov::convert ( const regexp::UnboundedRegExp < > & regexp ) {
- DefaultStateType q0 ( DefaultStatesPairType ( std::make_pair ( DefaultStateType ( 'q' ), DefaultStateType ( 0 ) ) ) );
+ DefaultStateType q0 ( DefaultStatesPairType ( ext::make_pair ( DefaultStateType ( 'q' ), DefaultStateType ( 0 ) ) ) );
automaton::NFA < > automaton ( q0 );
// step 1
automaton.setInputAlphabet ( regexp.getAlphabet ( ) );
- regexp::UnboundedRegExp < std::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( regexp );
+ regexp::UnboundedRegExp < ext::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( regexp );
// steps 2, 3, 4
- const ext::set < regexp::UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > > first = regexp::GlushkovFirst::first ( indexedRegExp );
- const ext::set < regexp::UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > > last = regexp::GlushkovLast::last ( indexedRegExp );
+ const ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > > first = regexp::GlushkovFirst::first ( indexedRegExp );
+ const ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > > last = regexp::GlushkovLast::last ( indexedRegExp );
// \e in q0 check is in step 7
// step 5
- for ( const std::pair < DefaultSymbolType, int > & symbol : indexedRegExp.getAlphabet ( ) )
+ for ( const ext::pair < DefaultSymbolType, int > & symbol : indexedRegExp.getAlphabet ( ) )
automaton.addState ( DefaultStateType ( container::ObjectsPair < DefaultSymbolType, int > ( symbol ) ) );
// step 6
- for ( const regexp::UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > & symbol : first )
+ for ( const regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > & symbol : first )
automaton.addTransition ( q0, symbol.getSymbol ( ).first, DefaultStateType ( container::ObjectsPair < DefaultSymbolType, int > ( symbol.getSymbol ( ) ) ) );
- for ( const std::pair < DefaultSymbolType, int > & x : indexedRegExp.getAlphabet ( ) )
- for ( const auto & f : regexp::GlushkovFollow::follow ( indexedRegExp, UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > ( x ) ) ) {
- const std::pair < DefaultSymbolType, int > & p = x;
- const std::pair < DefaultSymbolType, int > & q = f.getSymbol ( );
+ for ( const ext::pair < DefaultSymbolType, int > & x : indexedRegExp.getAlphabet ( ) )
+ for ( const auto & f : regexp::GlushkovFollow::follow ( indexedRegExp, UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > ( x ) ) ) {
+ const ext::pair < DefaultSymbolType, int > & p = x;
+ const ext::pair < DefaultSymbolType, int > & q = f.getSymbol ( );
automaton.addTransition ( DefaultStateType ( container::ObjectsPair < DefaultSymbolType, int > ( p ) ), q.first, DefaultStateType ( container::ObjectsPair < DefaultSymbolType, int > ( q ) ) );
}
// step 7
- for ( const regexp::UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > & symbol : last )
+ for ( const regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > & symbol : last )
automaton.addFinalState ( DefaultStateType ( container::ObjectsPair < DefaultSymbolType, int > ( symbol.getSymbol ( ) ) ) );
if ( regexp::properties::RegExpEpsilon::languageContainsEpsilon ( regexp ) )
@@ -75,8 +75,8 @@ automaton::NFA < > ToAutomatonGlushkov::convert ( const regexp::UnboundedRegExp
if ( regexp::properties::RegExpEpsilon::languageContainsEpsilon ( regexp ) )
std::clog << " q0 because #E in L(RE)" << std::endl;
- for ( const std::pair < DefaultSymbolType, int > & x : indexedRegExp.getAlphabet ( ) )
- std::clog << "Follow(" << x << ") = " << regexp::GlushkovFollow::follow ( indexedRegExp, UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > ( x ) ) << std::endl;
+ for ( const ext::pair < DefaultSymbolType, int > & x : indexedRegExp.getAlphabet ( ) )
+ std::clog << "Follow(" << x << ") = " << regexp::GlushkovFollow::follow ( indexedRegExp, UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > ( x ) ) << std::endl;
}
return automaton;
diff --git a/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.cpp b/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.cpp
index a65048a143be63569a9c6f76d0e0bc5017d34f50..842c18c83f1890912c16cfb55db695644ad4fd5c 100644
--- a/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.cpp
+++ b/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.cpp
@@ -87,7 +87,7 @@ grammar::RightRG < > ToGrammarRightRGDerivation::convert(const T& regexp) {
regexp::RegExp derived = regexp::RegExpDerivation::derivation(r, string);
derived = regexp::simplify::RegExpOptimize::optimize(derived);
- grammar.addRule(nonterminalMap.find(r)->second, std::make_pair(a, nonterminalMap.find(derived)->second));
+ grammar.addRule(nonterminalMap.find(r)->second, ext::make_pair(a, nonterminalMap.find(derived)->second));
if(regexp::properties::RegExpEpsilon::languageContainsEpsilon(derived))
grammar.addRule(nonterminalMap.find(r)->second, a);
diff --git a/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.cpp b/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.cpp
index 81e31b6ae12de3f2718100d3990be37af81ddc3f..bc04bb4cc22d42aff657e09c476066c6e9090094 100644
--- a/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.cpp
+++ b/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.cpp
@@ -35,28 +35,28 @@ grammar::RightRG < > ToGrammarRightRGGlushkov::convert ( const regexp::Unbounded
// step 1
grammar.setTerminalAlphabet ( regexp.getAlphabet ( ) );
- regexp::UnboundedRegExp < std::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( regexp );
+ regexp::UnboundedRegExp < ext::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( regexp );
// steps 2, 3, 4
- const ext::set < regexp::UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > > first = regexp::GlushkovFirst::first ( indexedRegExp );
- const ext::set < regexp::UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > > last = regexp::GlushkovLast::last ( indexedRegExp );
+ const ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > > first = regexp::GlushkovFirst::first ( indexedRegExp );
+ const ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > > last = regexp::GlushkovLast::last ( indexedRegExp );
// \e in q0 check is in step 7
// step 5
- for ( const std::pair < DefaultSymbolType, int > & symbol : indexedRegExp.getAlphabet ( ) )
+ for ( const ext::pair < DefaultSymbolType, int > & symbol : indexedRegExp.getAlphabet ( ) )
grammar.addNonterminalSymbol ( DefaultSymbolType ( container::ObjectsPair < DefaultSymbolType, int > ( symbol ) ) );
// step 6
- for ( const regexp::UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > & symbol : first )
- grammar.addRule ( S, std::make_pair ( symbol.getSymbol ( ).first, DefaultSymbolType ( container::ObjectsPair < DefaultSymbolType, int > ( symbol.getSymbol ( ) ) ) ) );
+ for ( const regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > & symbol : first )
+ grammar.addRule ( S, ext::make_pair ( symbol.getSymbol ( ).first, DefaultSymbolType ( container::ObjectsPair < DefaultSymbolType, int > ( symbol.getSymbol ( ) ) ) ) );
- for ( const std::pair < DefaultSymbolType, int > & x : indexedRegExp.getAlphabet ( ) )
- for ( const regexp::UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > & f : regexp::GlushkovFollow::follow ( indexedRegExp, UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > ( x ) ) ) {
- const std::pair < DefaultSymbolType, int > & a = x;
- const std::pair < DefaultSymbolType, int > & b = f.getSymbol ( );
+ for ( const ext::pair < DefaultSymbolType, int > & x : indexedRegExp.getAlphabet ( ) )
+ for ( const regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > & f : regexp::GlushkovFollow::follow ( indexedRegExp, UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > ( x ) ) ) {
+ const ext::pair < DefaultSymbolType, int > & a = x;
+ const ext::pair < DefaultSymbolType, int > & b = f.getSymbol ( );
- grammar.addRule ( DefaultSymbolType ( container::ObjectsPair < DefaultSymbolType, int > ( a ) ), std::make_pair ( b.first, DefaultSymbolType ( container::ObjectsPair < DefaultSymbolType, int > ( b ) ) ) );
+ grammar.addRule ( DefaultSymbolType ( container::ObjectsPair < DefaultSymbolType, int > ( a ) ), ext::make_pair ( b.first, DefaultSymbolType ( container::ObjectsPair < DefaultSymbolType, int > ( b ) ) ) );
}
// step 7
@@ -68,9 +68,9 @@ grammar::RightRG < > ToGrammarRightRGGlushkov::convert ( const regexp::Unbounded
*/
for ( const auto & rule : grammar.getRawRules ( ) ) {
for ( const auto & rhs : rule.second )
- for ( const regexp::UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > & symbol : last ) {
+ for ( const regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > & symbol : last ) {
- const std::pair < DefaultSymbolType, int > & a = symbol.getSymbol ( );
+ const ext::pair < DefaultSymbolType, int > & a = symbol.getSymbol ( );
if ( std::find ( rhs.begin ( ), rhs.end ( ), DefaultSymbolType ( container::ObjectsPair < DefaultSymbolType, int > ( a ) ) ) != rhs.end ( ) )
grammar.addRule ( rule.first, rhs.at ( 0 ) );
diff --git a/alib2algo/src/regexp/glushkov/GlushkovIndexate.h b/alib2algo/src/regexp/glushkov/GlushkovIndexate.h
index 4908fb6137f1070776f755a3eb5263414066e00b..3f088c2548957045061edb87d295e5948d8d9f4c 100644
--- a/alib2algo/src/regexp/glushkov/GlushkovIndexate.h
+++ b/alib2algo/src/regexp/glushkov/GlushkovIndexate.h
@@ -34,65 +34,65 @@ public:
* @return UnboundedRegExp with indexed elements
*/
template < class SymbolType >
- static regexp::UnboundedRegExp < std::pair < SymbolType, int > > index ( const regexp::UnboundedRegExp < SymbolType > & re );
+ static regexp::UnboundedRegExp < ext::pair < SymbolType, int > > index ( const regexp::UnboundedRegExp < SymbolType > & re );
template < class SymbolType >
class Unbounded {
public:
- static ext::rvalue_ref < regexp::UnboundedRegExpElement < std::pair < SymbolType, int > > > visit(const regexp::UnboundedRegExpAlternation < SymbolType > & alternation, int & i);
- static ext::rvalue_ref < regexp::UnboundedRegExpElement < std::pair < SymbolType, int > > > visit(const regexp::UnboundedRegExpConcatenation < SymbolType > & concatenation, int & i);
- static ext::rvalue_ref < regexp::UnboundedRegExpElement < std::pair < SymbolType, int > > > visit(const regexp::UnboundedRegExpIteration < SymbolType > & iteration, int & i);
- static ext::rvalue_ref < regexp::UnboundedRegExpElement < std::pair < SymbolType, int > > > visit(const regexp::UnboundedRegExpSymbol < SymbolType > & symbol, int & i);
- static ext::rvalue_ref < regexp::UnboundedRegExpElement < std::pair < SymbolType, int > > > visit(const regexp::UnboundedRegExpEpsilon < SymbolType > & epsilon, int & i);
- static ext::rvalue_ref < regexp::UnboundedRegExpElement < std::pair < SymbolType, int > > > visit(const regexp::UnboundedRegExpEmpty < SymbolType > & empty, int & i);
+ static ext::rvalue_ref < regexp::UnboundedRegExpElement < ext::pair < SymbolType, int > > > visit(const regexp::UnboundedRegExpAlternation < SymbolType > & alternation, int & i);
+ static ext::rvalue_ref < regexp::UnboundedRegExpElement < ext::pair < SymbolType, int > > > visit(const regexp::UnboundedRegExpConcatenation < SymbolType > & concatenation, int & i);
+ static ext::rvalue_ref < regexp::UnboundedRegExpElement < ext::pair < SymbolType, int > > > visit(const regexp::UnboundedRegExpIteration < SymbolType > & iteration, int & i);
+ static ext::rvalue_ref < regexp::UnboundedRegExpElement < ext::pair < SymbolType, int > > > visit(const regexp::UnboundedRegExpSymbol < SymbolType > & symbol, int & i);
+ static ext::rvalue_ref < regexp::UnboundedRegExpElement < ext::pair < SymbolType, int > > > visit(const regexp::UnboundedRegExpEpsilon < SymbolType > & epsilon, int & i);
+ static ext::rvalue_ref < regexp::UnboundedRegExpElement < ext::pair < SymbolType, int > > > visit(const regexp::UnboundedRegExpEmpty < SymbolType > & empty, int & i);
};
};
template < class SymbolType >
-UnboundedRegExp < std::pair < SymbolType, int > > GlushkovIndexate::index ( const regexp::UnboundedRegExp < SymbolType > & re ) {
+UnboundedRegExp < ext::pair < SymbolType, int > > GlushkovIndexate::index ( const regexp::UnboundedRegExp < SymbolType > & re ) {
int i = 1;
- return UnboundedRegExp < std::pair < SymbolType, int > > ( regexp::UnboundedRegExpStructure < std::pair < SymbolType, int > > ( re.getRegExp ( ).getStructure ( ).template accept < ext::rvalue_ref < regexp::UnboundedRegExpElement < std::pair < SymbolType, int > > >, GlushkovIndexate::Unbounded < SymbolType > > ( i ) ) );
+ return UnboundedRegExp < ext::pair < SymbolType, int > > ( regexp::UnboundedRegExpStructure < ext::pair < SymbolType, int > > ( re.getRegExp ( ).getStructure ( ).template accept < ext::rvalue_ref < regexp::UnboundedRegExpElement < ext::pair < SymbolType, int > > >, GlushkovIndexate::Unbounded < SymbolType > > ( i ) ) );
}
template < class SymbolType >
-ext::rvalue_ref < regexp::UnboundedRegExpElement < std::pair < SymbolType, int > > > GlushkovIndexate::Unbounded < SymbolType >::visit(const regexp::UnboundedRegExpAlternation < SymbolType > & alternation, int & i) {
- UnboundedRegExpAlternation < std::pair < SymbolType, int > > * alt = new UnboundedRegExpAlternation < std::pair < SymbolType, int > > ( );
+ext::rvalue_ref < regexp::UnboundedRegExpElement < ext::pair < SymbolType, int > > > GlushkovIndexate::Unbounded < SymbolType >::visit(const regexp::UnboundedRegExpAlternation < SymbolType > & alternation, int & i) {
+ UnboundedRegExpAlternation < ext::pair < SymbolType, int > > * alt = new UnboundedRegExpAlternation < ext::pair < SymbolType, int > > ( );
for ( const auto & element : alternation.getElements ( ) )
- alt->appendElement ( element->template accept < ext::rvalue_ref < regexp::UnboundedRegExpElement < std::pair < SymbolType, int > > >, GlushkovIndexate::Unbounded < SymbolType > > ( i ) );
+ alt->appendElement ( element->template accept < ext::rvalue_ref < regexp::UnboundedRegExpElement < ext::pair < SymbolType, int > > >, GlushkovIndexate::Unbounded < SymbolType > > ( i ) );
- return ext::rvalue_ref < UnboundedRegExpElement < std::pair < SymbolType, int > > > ( alt );
+ return ext::rvalue_ref < UnboundedRegExpElement < ext::pair < SymbolType, int > > > ( alt );
}
template < class SymbolType >
-ext::rvalue_ref < regexp::UnboundedRegExpElement < std::pair < SymbolType, int > > > GlushkovIndexate::Unbounded < SymbolType >::visit(const regexp::UnboundedRegExpConcatenation < SymbolType > & concatenation, int & i) {
- UnboundedRegExpConcatenation < std::pair < SymbolType, int > > * con = new UnboundedRegExpConcatenation < std::pair < SymbolType, int > > ( );
+ext::rvalue_ref < regexp::UnboundedRegExpElement < ext::pair < SymbolType, int > > > GlushkovIndexate::Unbounded < SymbolType >::visit(const regexp::UnboundedRegExpConcatenation < SymbolType > & concatenation, int & i) {
+ UnboundedRegExpConcatenation < ext::pair < SymbolType, int > > * con = new UnboundedRegExpConcatenation < ext::pair < SymbolType, int > > ( );
for ( const auto & element : concatenation.getElements ( ) )
- con->appendElement ( element->template accept < ext::rvalue_ref < regexp::UnboundedRegExpElement < std::pair < SymbolType, int > > >, GlushkovIndexate::Unbounded < SymbolType > > ( i ) );
+ con->appendElement ( element->template accept < ext::rvalue_ref < regexp::UnboundedRegExpElement < ext::pair < SymbolType, int > > >, GlushkovIndexate::Unbounded < SymbolType > > ( i ) );
- return ext::rvalue_ref < UnboundedRegExpElement < std::pair < SymbolType, int > > > ( con );
+ return ext::rvalue_ref < UnboundedRegExpElement < ext::pair < SymbolType, int > > > ( con );
}
template < class SymbolType >
-ext::rvalue_ref < regexp::UnboundedRegExpElement < std::pair < SymbolType, int > > > GlushkovIndexate::Unbounded < SymbolType >::visit(const regexp::UnboundedRegExpIteration < SymbolType > & iteration, int & i) {
- return ext::rvalue_ref < UnboundedRegExpElement < std::pair < SymbolType, int > > > ( new UnboundedRegExpIteration < std::pair < SymbolType, int > > ( iteration.getElement ( ).template accept < ext::rvalue_ref < regexp::UnboundedRegExpElement < std::pair < DefaultSymbolType, int > > >, GlushkovIndexate::Unbounded < SymbolType > > ( i ) ) );
+ext::rvalue_ref < regexp::UnboundedRegExpElement < ext::pair < SymbolType, int > > > GlushkovIndexate::Unbounded < SymbolType >::visit(const regexp::UnboundedRegExpIteration < SymbolType > & iteration, int & i) {
+ return ext::rvalue_ref < UnboundedRegExpElement < ext::pair < SymbolType, int > > > ( new UnboundedRegExpIteration < ext::pair < SymbolType, int > > ( iteration.getElement ( ).template accept < ext::rvalue_ref < regexp::UnboundedRegExpElement < ext::pair < DefaultSymbolType, int > > >, GlushkovIndexate::Unbounded < SymbolType > > ( i ) ) );
}
template < class SymbolType >
-ext::rvalue_ref < regexp::UnboundedRegExpElement < std::pair < SymbolType, int > > > GlushkovIndexate::Unbounded < SymbolType >::visit(const regexp::UnboundedRegExpSymbol < SymbolType > & symbol, int & i) {
- return ext::rvalue_ref < UnboundedRegExpElement < std::pair < SymbolType, int > > > ( new UnboundedRegExpSymbol < std::pair < SymbolType, int > > ( std::make_pair ( symbol.getSymbol ( ), i++ ) ) );
+ext::rvalue_ref < regexp::UnboundedRegExpElement < ext::pair < SymbolType, int > > > GlushkovIndexate::Unbounded < SymbolType >::visit(const regexp::UnboundedRegExpSymbol < SymbolType > & symbol, int & i) {
+ return ext::rvalue_ref < UnboundedRegExpElement < ext::pair < SymbolType, int > > > ( new UnboundedRegExpSymbol < ext::pair < SymbolType, int > > ( ext::make_pair ( symbol.getSymbol ( ), i++ ) ) );
}
template < class SymbolType >
-ext::rvalue_ref < regexp::UnboundedRegExpElement < std::pair < SymbolType, int > > > GlushkovIndexate::Unbounded < SymbolType >::visit(const regexp::UnboundedRegExpEpsilon < SymbolType > &, int &) {
- return ext::rvalue_ref < UnboundedRegExpElement < std::pair < SymbolType, int > > > ( new UnboundedRegExpEpsilon < std::pair < SymbolType, int > > ( ) );
+ext::rvalue_ref < regexp::UnboundedRegExpElement < ext::pair < SymbolType, int > > > GlushkovIndexate::Unbounded < SymbolType >::visit(const regexp::UnboundedRegExpEpsilon < SymbolType > &, int &) {
+ return ext::rvalue_ref < UnboundedRegExpElement < ext::pair < SymbolType, int > > > ( new UnboundedRegExpEpsilon < ext::pair < SymbolType, int > > ( ) );
}
template < class SymbolType >
-ext::rvalue_ref < regexp::UnboundedRegExpElement < std::pair < SymbolType, int > > > GlushkovIndexate::Unbounded < SymbolType >::visit(const regexp::UnboundedRegExpEmpty < SymbolType > &, int &) {
- return ext::rvalue_ref < UnboundedRegExpElement < std::pair < SymbolType, int > > > ( new UnboundedRegExpEmpty < std::pair < SymbolType, int > > ( ) );
+ext::rvalue_ref < regexp::UnboundedRegExpElement < ext::pair < SymbolType, int > > > GlushkovIndexate::Unbounded < SymbolType >::visit(const regexp::UnboundedRegExpEmpty < SymbolType > &, int &) {
+ return ext::rvalue_ref < UnboundedRegExpElement < ext::pair < SymbolType, int > > > ( new UnboundedRegExpEmpty < ext::pair < SymbolType, int > > ( ) );
}
} /* namespace regexp */
diff --git a/alib2algo/src/rte/glushkov/GlushkovIndexate.cpp b/alib2algo/src/rte/glushkov/GlushkovIndexate.cpp
index 055f34edfb57adc3625ad14700dd29db5deee7fb..0bb192b59a5141840a2856f938c41433039bb704 100644
--- a/alib2algo/src/rte/glushkov/GlushkovIndexate.cpp
+++ b/alib2algo/src/rte/glushkov/GlushkovIndexate.cpp
@@ -14,7 +14,7 @@
namespace rte {
common::ranked_symbol < > GlushkovIndexate::getSymbolFromGlushkovPair ( const common::ranked_symbol < > & symbol ) {
- const std::pair < DefaultSymbolType, DefaultSymbolType > & sps = ( ( const DefaultSymbolsPairType & ) symbol.getSymbol ( ).getData ( ) );
+ const ext::pair < DefaultSymbolType, DefaultSymbolType > & sps = ( ( const DefaultSymbolsPairType & ) symbol.getSymbol ( ).getData ( ) );
return common::ranked_symbol < > ( sps.first, symbol.getRank ( ) );
}
@@ -26,7 +26,7 @@ FormalRTE < > GlushkovIndexate::index ( const rte::FormalRTE < > & rte ) {
}
ext::rvalue_ref < FormalRTEElement < DefaultSymbolType, primitive::Unsigned > > GlushkovIndexate::Formal::visit ( const rte::FormalRTESymbolAlphabet < DefaultSymbolType, primitive::Unsigned > & node, int & i ) {
- DefaultSymbolsPairType sps = DefaultSymbolsPairType ( std::make_pair ( DefaultSymbolType ( node.getSymbol ( ).getSymbol ( ) ), DefaultSymbolType ( i++ ) ) );
+ DefaultSymbolsPairType sps = DefaultSymbolsPairType ( ext::make_pair ( DefaultSymbolType ( node.getSymbol ( ).getSymbol ( ) ), DefaultSymbolType ( i++ ) ) );
FormalRTESymbolAlphabet < DefaultSymbolType, primitive::Unsigned > * ns = new FormalRTESymbolAlphabet < DefaultSymbolType, primitive::Unsigned > ( common::ranked_symbol < > ( DefaultSymbolType ( sps ), node.getSymbol ( ).getRank ( ) ) );
for ( const ext::smart_ptr < const rte::FormalRTESymbol < DefaultSymbolType, primitive::Unsigned > > & e : node.getElements ( ) ) {
diff --git a/alib2algo/src/string/properties/GoodSuffixShiftTable.h b/alib2algo/src/string/properties/GoodSuffixShiftTable.h
index d60b461ad0145f9655253c36bbaff91db01223a2..1e961018b6f6cef7eeaa1b7bd982dd0ad9e58567 100644
--- a/alib2algo/src/string/properties/GoodSuffixShiftTable.h
+++ b/alib2algo/src/string/properties/GoodSuffixShiftTable.h
@@ -57,7 +57,7 @@ ext::vector < size_t > GoodSuffixShiftTable::gss ( const string::LinearString <
ext::set < unsigned > state = factorAutomaton.getInitialState ( );
result.push_back ( 1 );
for ( const SymbolType & symbol : reversed.getContent ( ) ) {
- state = factorAutomaton.getTransitions ( ).find ( std::make_pair ( std::move ( state ), symbol ) )->second;
+ state = factorAutomaton.getTransitions ( ).find ( ext::make_pair ( std::move ( state ), symbol ) )->second;
if ( state.size ( ) >= 2 ) {
unsigned first = * state.begin ( );
unsigned second = * std::next ( state.begin ( ) );
diff --git a/alib2algo/src/stringology/indexing/ExactMultiNondeterministicSubsequenceAutomaton.h b/alib2algo/src/stringology/indexing/ExactMultiNondeterministicSubsequenceAutomaton.h
index d9aeab07d532cf6ac96c42b520930c8be5106b3a..e03306473f3834a57b8cc8ea270611897bb379d9 100644
--- a/alib2algo/src/stringology/indexing/ExactMultiNondeterministicSubsequenceAutomaton.h
+++ b/alib2algo/src/stringology/indexing/ExactMultiNondeterministicSubsequenceAutomaton.h
@@ -28,29 +28,29 @@ public:
static automaton::Automaton construct ( const ext::set < string::String > & text );
template < class SymbolType >
- static automaton::EpsilonNFA < SymbolType, DefaultEpsilonType, std::pair < unsigned, unsigned > > construct ( const ext::set < string::LinearString < SymbolType > > & text);
+ static automaton::EpsilonNFA < SymbolType, DefaultEpsilonType, ext::pair < unsigned, unsigned > > construct ( const ext::set < string::LinearString < SymbolType > > & text);
};
template < class SymbolType >
-automaton::EpsilonNFA < SymbolType, DefaultEpsilonType, std::pair < unsigned, unsigned > > ExactMultiNondeterministicSubsequenceAutomaton::construct ( const ext::set < string::LinearString < SymbolType > > & texts) {
- automaton::EpsilonNFA < SymbolType, DefaultEpsilonType, std::pair < unsigned, unsigned > > res ( std::make_pair ( 0u, 0u ) );
- res.addFinalState ( std::make_pair ( 0u, 0u ) );
+automaton::EpsilonNFA < SymbolType, DefaultEpsilonType, ext::pair < unsigned, unsigned > > ExactMultiNondeterministicSubsequenceAutomaton::construct ( const ext::set < string::LinearString < SymbolType > > & texts) {
+ automaton::EpsilonNFA < SymbolType, DefaultEpsilonType, ext::pair < unsigned, unsigned > > res ( ext::make_pair ( 0u, 0u ) );
+ res.addFinalState ( ext::make_pair ( 0u, 0u ) );
unsigned j = 1;
for ( const string::LinearString < SymbolType > & text : texts ) {
res.addInputSymbols ( text.getAlphabet ( ) );
- res.addState ( std::make_pair ( 0u, j ) );
- res.addFinalState ( std::make_pair ( 0u, j ) );
- res.addTransition ( std::make_pair ( 0u, 0u ), std::make_pair ( 0u, j ) );
+ res.addState ( ext::make_pair ( 0u, j ) );
+ res.addFinalState ( ext::make_pair ( 0u, j ) );
+ res.addTransition ( ext::make_pair ( 0u, 0u ), ext::make_pair ( 0u, j ) );
unsigned i = 1;
for ( const SymbolType & symbol : text.getContent ( ) ) {
- res.addState ( std::make_pair ( i, j ) );
- res.addFinalState ( std::make_pair ( i, j ) );
+ res.addState ( ext::make_pair ( i, j ) );
+ res.addFinalState ( ext::make_pair ( i, j ) );
- res.addTransition ( std::make_pair ( i - 1, j ), symbol, std::make_pair ( i, j ) );
- res.addTransition ( std::make_pair ( i - 1, j ), std::make_pair ( i, j ) );
+ res.addTransition ( ext::make_pair ( i - 1, j ), symbol, ext::make_pair ( i, j ) );
+ res.addTransition ( ext::make_pair ( i - 1, j ), ext::make_pair ( i, j ) );
i++;
}
j++;
diff --git a/alib2algo/src/tree/properties/ExactSubtreeRepeats.h b/alib2algo/src/tree/properties/ExactSubtreeRepeats.h
index 86bea96a5b666c826e6cacc116ec67a5d67a7ca6..dec06172be49a4ae4f017a7c5349c280db1122b7 100644
--- a/alib2algo/src/tree/properties/ExactSubtreeRepeats.h
+++ b/alib2algo/src/tree/properties/ExactSubtreeRepeats.h
@@ -153,14 +153,14 @@ ExactSubtreeRepeats::ExactSubtreeRepeatsAux::ExactSubtreeRepeatsAux ( const ext:
template < class SymbolType, class RankType >
void ExactSubtreeRepeats::ExactSubtreeRepeatsAux::buildMu ( const ext::vector < common::ranked_symbol < SymbolType, RankType > > & symbols ) {
// Build mapping mu_map((Symb, Rank) -> Number) and construct array mu from it
- ext::map < std::pair < SymbolType, RankType >, unsigned > mu_map;
+ ext::map < ext::pair < SymbolType, RankType >, unsigned > mu_map;
this->alphabetSize = 0;
for ( auto it = symbols.begin ( ); it != symbols.end ( ); it++ ) {
- auto search = mu_map.find ( std::make_pair ( it->getSymbol ( ), it->getRank ( ) ) );
+ auto search = mu_map.find ( ext::make_pair ( it->getSymbol ( ), it->getRank ( ) ) );
if ( search == mu_map.end ( ) ) {
- mu_map.insert ( std::make_pair ( std::make_pair ( it->getSymbol ( ), it->getRank ( ) ), this->alphabetSize ) );
+ mu_map.insert ( std::make_pair ( ext::make_pair ( it->getSymbol ( ), it->getRank ( ) ), this->alphabetSize ) );
mu.push_back ( this->alphabetSize );
this->alphabetSize += 1;
} else {
diff --git a/alib2algo/test-src/automaton/simplify/trimTest.cpp b/alib2algo/test-src/automaton/simplify/trimTest.cpp
index 13f9aa0534e88e22c1073e1b87956093a08279a2..f768eec567bf33158d36edc09148d26fd58752e5 100644
--- a/alib2algo/test-src/automaton/simplify/trimTest.cpp
+++ b/alib2algo/test-src/automaton/simplify/trimTest.cpp
@@ -49,14 +49,14 @@ void trimTest::testTrimGrammar() {
rrGrammar.addTerminalSymbol(DefaultSymbolType("a"));
rrGrammar.addTerminalSymbol(DefaultSymbolType("b"));
- rrGrammar.addRule(DefaultSymbolType(1), std::make_pair(DefaultSymbolType("a"), DefaultSymbolType(2)));
- rrGrammar.addRule(DefaultSymbolType(2), std::make_pair(DefaultSymbolType("b"), DefaultSymbolType(3)));
+ rrGrammar.addRule(DefaultSymbolType(1), ext::make_pair(DefaultSymbolType("a"), DefaultSymbolType(2)));
+ rrGrammar.addRule(DefaultSymbolType(2), ext::make_pair(DefaultSymbolType("b"), DefaultSymbolType(3)));
rrGrammar.addRule(DefaultSymbolType(3), DefaultSymbolType("a"));
- rrGrammar.addRule(DefaultSymbolType(4), std::make_pair(DefaultSymbolType("b"), DefaultSymbolType(5)));
+ rrGrammar.addRule(DefaultSymbolType(4), ext::make_pair(DefaultSymbolType("b"), DefaultSymbolType(5)));
rrGrammar.addRule(DefaultSymbolType(5), DefaultSymbolType("a"));
- rrGrammar.addRule(DefaultSymbolType(5), std::make_pair(DefaultSymbolType("b"), DefaultSymbolType(2)));
- rrGrammar.addRule(DefaultSymbolType(6), std::make_pair(DefaultSymbolType("b"), DefaultSymbolType(6)));
+ rrGrammar.addRule(DefaultSymbolType(5), ext::make_pair(DefaultSymbolType("b"), DefaultSymbolType(2)));
+ rrGrammar.addRule(DefaultSymbolType(6), ext::make_pair(DefaultSymbolType("b"), DefaultSymbolType(6)));
grammar::RightRG < > trimed = grammar::simplify::Trim::trim(rrGrammar);
diff --git a/alib2algo/test-src/grammar/properties/GrammarPropertiesTest.cpp b/alib2algo/test-src/grammar/properties/GrammarPropertiesTest.cpp
index 6500f22302cdd1c0a1c28863a2e63fa577d6fa79..3ff696c633d8ec0179bab1cd74e57f4fdcc98d6f 100644
--- a/alib2algo/test-src/grammar/properties/GrammarPropertiesTest.cpp
+++ b/alib2algo/test-src/grammar/properties/GrammarPropertiesTest.cpp
@@ -52,15 +52,15 @@ void GrammarPropertiesTest::testUnitRules() {
llg.setNonterminalAlphabet({S, A, B, C});
llg.setInitialSymbol(S);
- llg.addRule(S, std::make_pair(A, ext::vector<DefaultSymbolType>{}));
- llg.addRule(S, std::make_pair(B, ext::vector<DefaultSymbolType>{}));
- llg.addRule(A, std::make_pair(A, ext::vector<DefaultSymbolType>{a}));
- llg.addRule(A, std::make_pair(B, ext::vector<DefaultSymbolType>{}));
- llg.addRule(A, std::make_pair(C, ext::vector<DefaultSymbolType>{}));
- llg.addRule(B, std::make_pair(B, ext::vector<DefaultSymbolType>{b, a}));
- llg.addRule(B, std::make_pair(C, ext::vector<DefaultSymbolType>{b}));
+ llg.addRule(S, ext::make_pair(A, ext::vector<DefaultSymbolType>{}));
+ llg.addRule(S, ext::make_pair(B, ext::vector<DefaultSymbolType>{}));
+ llg.addRule(A, ext::make_pair(A, ext::vector<DefaultSymbolType>{a}));
+ llg.addRule(A, ext::make_pair(B, ext::vector<DefaultSymbolType>{}));
+ llg.addRule(A, ext::make_pair(C, ext::vector<DefaultSymbolType>{}));
+ llg.addRule(B, ext::make_pair(B, ext::vector<DefaultSymbolType>{b, a}));
+ llg.addRule(B, ext::make_pair(C, ext::vector<DefaultSymbolType>{b}));
llg.addRule(C, {b});
- llg.addRule(C, std::make_pair(C, ext::vector<DefaultSymbolType>{a}));
+ llg.addRule(C, ext::make_pair(C, ext::vector<DefaultSymbolType>{a}));
ext::set<DefaultSymbolType> N_S = {S, A, B, C};
ext::set<DefaultSymbolType> N_A = {A, B, C};
diff --git a/alib2algo/test-src/grammar/simplify/GrammarToCNFTest.cpp b/alib2algo/test-src/grammar/simplify/GrammarToCNFTest.cpp
index 153db1a2113f7915f2592c7cbc3f30c1d671d862..1b7b509f53b435fea7bf83e39bad5c836a7a36d4 100644
--- a/alib2algo/test-src/grammar/simplify/GrammarToCNFTest.cpp
+++ b/alib2algo/test-src/grammar/simplify/GrammarToCNFTest.cpp
@@ -72,26 +72,26 @@ void GrammarToCNFTest::testToCNFRules2() {
DefaultSymbolType aP = DefaultSymbolType("a'");
DefaultSymbolType bP = DefaultSymbolType("b'");
DefaultSymbolType cP = DefaultSymbolType("c'");
- DefaultSymbolType Xb = DefaultSymbolType(DefaultSymbolType(DefaultSymbolsPairType(std::make_pair(X, b))));
- DefaultSymbolType aX = DefaultSymbolType(DefaultSymbolType(DefaultSymbolsPairType(std::make_pair(a, X))));
- DefaultSymbolType bX = DefaultSymbolType(DefaultSymbolType(DefaultSymbolsPairType(std::make_pair(b, X))));
+ DefaultSymbolType Xb = DefaultSymbolType(DefaultSymbolType(DefaultSymbolsPairType(ext::make_pair(X, b))));
+ DefaultSymbolType aX = DefaultSymbolType(DefaultSymbolType(DefaultSymbolsPairType(ext::make_pair(a, X))));
+ DefaultSymbolType bX = DefaultSymbolType(DefaultSymbolType(DefaultSymbolsPairType(ext::make_pair(b, X))));
grammar::CNF < > grammar3(S);
grammar3.setNonterminalAlphabet({S, X, Y, aP, bP, cP, Xb, aX, bX});
grammar3.setTerminalAlphabet({a, b, c});
- grammar3.addRule(S, std::make_pair(aX, bX));
- grammar3.addRule(S, std::make_pair(aP, bX));
- grammar3.addRule(S, std::make_pair(aP, Xb));
- grammar3.addRule(S, std::make_pair(aP, bP));
- grammar3.addRule(aX, std::make_pair(aP, X));
- grammar3.addRule(bX, std::make_pair(bP, X));
- grammar3.addRule(Xb, std::make_pair(X, bP));
- grammar3.addRule(X, std::make_pair(aP, Y));
- grammar3.addRule(X, std::make_pair(bP, Y));
+ grammar3.addRule(S, ext::make_pair(aX, bX));
+ grammar3.addRule(S, ext::make_pair(aP, bX));
+ grammar3.addRule(S, ext::make_pair(aP, Xb));
+ grammar3.addRule(S, ext::make_pair(aP, bP));
+ grammar3.addRule(aX, ext::make_pair(aP, X));
+ grammar3.addRule(bX, ext::make_pair(bP, X));
+ grammar3.addRule(Xb, ext::make_pair(X, bP));
+ grammar3.addRule(X, ext::make_pair(aP, Y));
+ grammar3.addRule(X, ext::make_pair(bP, Y));
grammar3.addRule(X, a);
grammar3.addRule(X, b);
- grammar3.addRule(Y, std::make_pair(aP, Y));
- grammar3.addRule(Y, std::make_pair(bP, Y));
+ grammar3.addRule(Y, ext::make_pair(aP, Y));
+ grammar3.addRule(Y, ext::make_pair(bP, Y));
grammar3.addRule(Y, a);
grammar3.addRule(Y, b);
grammar3.addRule(Y, c);
diff --git a/alib2algo/test-src/grammar/simplify/GrammarToGNFTest.cpp b/alib2algo/test-src/grammar/simplify/GrammarToGNFTest.cpp
index 8c036c403058d473465ce91d114a7503b51e2050..b9409f5ed4a9ed1f7dfd773a41b8458f77cac0ac 100644
--- a/alib2algo/test-src/grammar/simplify/GrammarToGNFTest.cpp
+++ b/alib2algo/test-src/grammar/simplify/GrammarToGNFTest.cpp
@@ -40,8 +40,8 @@ void GrammarToGNFTest::testRemoveToGNFRules1() {
grammar::GNF < > grammar3(S);
grammar3.setNonterminalAlphabet({S, A, B, C, D, aprimed, bprimed});
grammar3.setTerminalAlphabet({a, b});
- grammar3.addRule(aprimed, std::make_pair(a, ext::vector<DefaultSymbolType>{}));
- grammar3.addRule(bprimed, std::make_pair(b, ext::vector<DefaultSymbolType>{}));
+ grammar3.addRule(aprimed, ext::make_pair(a, ext::vector<DefaultSymbolType>{}));
+ grammar3.addRule(bprimed, ext::make_pair(b, ext::vector<DefaultSymbolType>{}));
std::cout << alib::StringDataFactory::toString<grammar::Grammar>(grammar::Grammar(grammar2)) << std::endl;
std::cout << alib::StringDataFactory::toString<grammar::Grammar>(grammar::Grammar(grammar3)) << std::endl;
@@ -80,17 +80,17 @@ void GrammarToGNFTest::testRemoveToGNFRules2() {
grammar::GNF < > grammar3(S);
grammar3.setNonterminalAlphabet({S, A, Aprimed, B, C, D, aprimed, bprimed, cprimed});
grammar3.setTerminalAlphabet({a, b, c});
- grammar3.addRule(S, std::make_pair(c, ext::vector<DefaultSymbolType>{Aprimed}));
- grammar3.addRule(S, std::make_pair(c, ext::vector<DefaultSymbolType>{}));
- grammar3.addRule(A, std::make_pair(c, ext::vector<DefaultSymbolType>{Aprimed}));
- grammar3.addRule(A, std::make_pair(c, ext::vector<DefaultSymbolType>{}));
- grammar3.addRule(Aprimed, std::make_pair(a, ext::vector<DefaultSymbolType>{Aprimed}));
- grammar3.addRule(Aprimed, std::make_pair(a, ext::vector<DefaultSymbolType>{}));
- grammar3.addRule(Aprimed, std::make_pair(b, ext::vector<DefaultSymbolType>{Aprimed}));
- grammar3.addRule(Aprimed, std::make_pair(b, ext::vector<DefaultSymbolType>{}));
- grammar3.addRule(aprimed, std::make_pair(a, ext::vector<DefaultSymbolType>{}));
- grammar3.addRule(bprimed, std::make_pair(b, ext::vector<DefaultSymbolType>{}));
- grammar3.addRule(cprimed, std::make_pair(c, ext::vector<DefaultSymbolType>{}));
+ grammar3.addRule(S, ext::make_pair(c, ext::vector<DefaultSymbolType>{Aprimed}));
+ grammar3.addRule(S, ext::make_pair(c, ext::vector<DefaultSymbolType>{}));
+ grammar3.addRule(A, ext::make_pair(c, ext::vector<DefaultSymbolType>{Aprimed}));
+ grammar3.addRule(A, ext::make_pair(c, ext::vector<DefaultSymbolType>{}));
+ grammar3.addRule(Aprimed, ext::make_pair(a, ext::vector<DefaultSymbolType>{Aprimed}));
+ grammar3.addRule(Aprimed, ext::make_pair(a, ext::vector<DefaultSymbolType>{}));
+ grammar3.addRule(Aprimed, ext::make_pair(b, ext::vector<DefaultSymbolType>{Aprimed}));
+ grammar3.addRule(Aprimed, ext::make_pair(b, ext::vector<DefaultSymbolType>{}));
+ grammar3.addRule(aprimed, ext::make_pair(a, ext::vector<DefaultSymbolType>{}));
+ grammar3.addRule(bprimed, ext::make_pair(b, ext::vector<DefaultSymbolType>{}));
+ grammar3.addRule(cprimed, ext::make_pair(c, ext::vector<DefaultSymbolType>{}));
std::cout << alib::StringDataFactory::toString<grammar::Grammar>(grammar::Grammar(grammar2)) << std::endl;
std::cout << alib::StringDataFactory::toString<grammar::Grammar>(grammar::Grammar(grammar3)) << std::endl;
@@ -128,19 +128,19 @@ void GrammarToGNFTest::testRemoveToGNFRules3() {
grammar::GNF < > grammar3(S);
grammar3.setNonterminalAlphabet({S, A, B, Bprimed, C, aprimed, bprimed, cprimed});
grammar3.setTerminalAlphabet({a, b, c});
- grammar3.addRule(S, std::make_pair(c, ext::vector<DefaultSymbolType>{}));
- grammar3.addRule(S, std::make_pair(c, ext::vector<DefaultSymbolType>{bprimed, Bprimed, aprimed}));
- grammar3.addRule(S, std::make_pair(c, ext::vector<DefaultSymbolType>{bprimed, aprimed}));
- grammar3.addRule(A, std::make_pair(c, ext::vector<DefaultSymbolType>{bprimed, aprimed}));
- grammar3.addRule(A, std::make_pair(c, ext::vector<DefaultSymbolType>{bprimed, Bprimed, aprimed}));
- grammar3.addRule(A, std::make_pair(c, ext::vector<DefaultSymbolType>{}));
- grammar3.addRule(B, std::make_pair(c, ext::vector<DefaultSymbolType>{bprimed}));
- grammar3.addRule(B, std::make_pair(c, ext::vector<DefaultSymbolType>{bprimed, Bprimed}));
- grammar3.addRule(Bprimed, std::make_pair(a, ext::vector<DefaultSymbolType>{bprimed, Bprimed}));
- grammar3.addRule(Bprimed, std::make_pair(a, ext::vector<DefaultSymbolType>{bprimed}));
- grammar3.addRule(aprimed, std::make_pair(a, ext::vector<DefaultSymbolType>{}));
- grammar3.addRule(bprimed, std::make_pair(b, ext::vector<DefaultSymbolType>{}));
- grammar3.addRule(cprimed, std::make_pair(c, ext::vector<DefaultSymbolType>{}));
+ grammar3.addRule(S, ext::make_pair(c, ext::vector<DefaultSymbolType>{}));
+ grammar3.addRule(S, ext::make_pair(c, ext::vector<DefaultSymbolType>{bprimed, Bprimed, aprimed}));
+ grammar3.addRule(S, ext::make_pair(c, ext::vector<DefaultSymbolType>{bprimed, aprimed}));
+ grammar3.addRule(A, ext::make_pair(c, ext::vector<DefaultSymbolType>{bprimed, aprimed}));
+ grammar3.addRule(A, ext::make_pair(c, ext::vector<DefaultSymbolType>{bprimed, Bprimed, aprimed}));
+ grammar3.addRule(A, ext::make_pair(c, ext::vector<DefaultSymbolType>{}));
+ grammar3.addRule(B, ext::make_pair(c, ext::vector<DefaultSymbolType>{bprimed}));
+ grammar3.addRule(B, ext::make_pair(c, ext::vector<DefaultSymbolType>{bprimed, Bprimed}));
+ grammar3.addRule(Bprimed, ext::make_pair(a, ext::vector<DefaultSymbolType>{bprimed, Bprimed}));
+ grammar3.addRule(Bprimed, ext::make_pair(a, ext::vector<DefaultSymbolType>{bprimed}));
+ grammar3.addRule(aprimed, ext::make_pair(a, ext::vector<DefaultSymbolType>{}));
+ grammar3.addRule(bprimed, ext::make_pair(b, ext::vector<DefaultSymbolType>{}));
+ grammar3.addRule(cprimed, ext::make_pair(c, ext::vector<DefaultSymbolType>{}));
std::cout << alib::StringDataFactory::toString<grammar::Grammar>(grammar::Grammar(grammar2)) << std::endl;
std::cout << alib::StringDataFactory::toString<grammar::Grammar>(grammar::Grammar(grammar3)) << std::endl;
diff --git a/alib2algo/test-src/grammar/toGrammar/rg2rgTest.cpp b/alib2algo/test-src/grammar/toGrammar/rg2rgTest.cpp
index 3facdea2478f21037ade54d4939d605bb9639a2f..47d09ee259a929198b832e6326c7a8b342221a32 100644
--- a/alib2algo/test-src/grammar/toGrammar/rg2rgTest.cpp
+++ b/alib2algo/test-src/grammar/toGrammar/rg2rgTest.cpp
@@ -22,8 +22,8 @@ void rg2rgTest::testConversion() {
rrGrammar.addTerminalSymbol(DefaultSymbolType("a"));
rrGrammar.addTerminalSymbol(DefaultSymbolType("b"));
- rrGrammar.addRule(DefaultSymbolType(1), std::make_pair(DefaultSymbolType("a"), DefaultSymbolType(2)));
- rrGrammar.addRule(DefaultSymbolType(2), std::make_pair(DefaultSymbolType("b"), DefaultSymbolType(3)));
+ rrGrammar.addRule(DefaultSymbolType(1), ext::make_pair(DefaultSymbolType("a"), DefaultSymbolType(2)));
+ rrGrammar.addRule(DefaultSymbolType(2), ext::make_pair(DefaultSymbolType("b"), DefaultSymbolType(3)));
rrGrammar.addRule(DefaultSymbolType(3), DefaultSymbolType("a"));
grammar::LeftRG < > lrGrammar = grammar::convert::ToGrammarLeftRG::convert(rrGrammar);
@@ -36,10 +36,10 @@ void rg2rgTest::testConversion() {
lrGrammarRef.addTerminalSymbol(DefaultSymbolType("a"));
lrGrammarRef.addTerminalSymbol(DefaultSymbolType("b"));
- lrGrammarRef.addRule(DefaultSymbolType(2), std::make_pair(DefaultSymbolType(1), DefaultSymbolType("a")));
+ lrGrammarRef.addRule(DefaultSymbolType(2), ext::make_pair(DefaultSymbolType(1), DefaultSymbolType("a")));
lrGrammarRef.addRule(DefaultSymbolType(2), DefaultSymbolType("a"));
- lrGrammarRef.addRule(DefaultSymbolType(3), std::make_pair(DefaultSymbolType(2), DefaultSymbolType("b")));
- lrGrammarRef.addRule(DefaultSymbolType(4), std::make_pair(DefaultSymbolType(3), DefaultSymbolType("a")));
+ lrGrammarRef.addRule(DefaultSymbolType(3), ext::make_pair(DefaultSymbolType(2), DefaultSymbolType("b")));
+ lrGrammarRef.addRule(DefaultSymbolType(4), ext::make_pair(DefaultSymbolType(3), DefaultSymbolType("a")));
CPPUNIT_ASSERT(lrGrammarRef == lrGrammar);
}
@@ -54,8 +54,8 @@ void rg2rgTest::testConversion2() {
lrGrammar.addTerminalSymbol(DefaultSymbolType("b"));
lrGrammar.addRule(DefaultSymbolType(2), DefaultSymbolType("a"));
- lrGrammar.addRule(DefaultSymbolType(3), std::make_pair(DefaultSymbolType(2), DefaultSymbolType("b")));
- lrGrammar.addRule(DefaultSymbolType(4), std::make_pair(DefaultSymbolType(3), DefaultSymbolType("a")));
+ lrGrammar.addRule(DefaultSymbolType(3), ext::make_pair(DefaultSymbolType(2), DefaultSymbolType("b")));
+ lrGrammar.addRule(DefaultSymbolType(4), ext::make_pair(DefaultSymbolType(3), DefaultSymbolType("a")));
grammar::RightRG < > rrGrammar = grammar::convert::ToGrammarRightRG::convert(lrGrammar);
@@ -67,10 +67,10 @@ void rg2rgTest::testConversion2() {
rrGrammarRef.addTerminalSymbol(DefaultSymbolType("a"));
rrGrammarRef.addTerminalSymbol(DefaultSymbolType("b"));
- rrGrammarRef.addRule(DefaultSymbolType(5), std::make_pair(DefaultSymbolType("a"), DefaultSymbolType(2)));
- rrGrammarRef.addRule(DefaultSymbolType(2), std::make_pair(DefaultSymbolType("b"), DefaultSymbolType(3)));
+ rrGrammarRef.addRule(DefaultSymbolType(5), ext::make_pair(DefaultSymbolType("a"), DefaultSymbolType(2)));
+ rrGrammarRef.addRule(DefaultSymbolType(2), ext::make_pair(DefaultSymbolType("b"), DefaultSymbolType(3)));
rrGrammarRef.addRule(DefaultSymbolType(3), DefaultSymbolType("a"));
- rrGrammarRef.addRule(DefaultSymbolType(3), std::make_pair(DefaultSymbolType("a"), DefaultSymbolType(4)));
+ rrGrammarRef.addRule(DefaultSymbolType(3), ext::make_pair(DefaultSymbolType("a"), DefaultSymbolType(4)));
CPPUNIT_ASSERT(rrGrammarRef == rrGrammar);
}
diff --git a/alib2algo/test-src/regexp/RegExpTest.cpp b/alib2algo/test-src/regexp/RegExpTest.cpp
index 8edb3912d4eb00ef6230eb2bb5159b304a81f526..f2285f1e018ea35872fcfa8278dee81bcd2872e0 100644
--- a/alib2algo/test-src/regexp/RegExpTest.cpp
+++ b/alib2algo/test-src/regexp/RegExpTest.cpp
@@ -28,18 +28,18 @@ void RegExpTest::testFirst ( ) {
{
std::string input = "#E* #0*";
regexp::RegExp regexp = alib::StringDataFactory::fromString ( input );
- regexp::UnboundedRegExp < std::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( static_cast < const regexp::UnboundedRegExp < > & > ( regexp.getData ( ) ) );
+ regexp::UnboundedRegExp < ext::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( static_cast < const regexp::UnboundedRegExp < > & > ( regexp.getData ( ) ) );
- ext::set < regexp::UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > > first = regexp::GlushkovFirst::first ( indexedRegExp );
+ ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > > first = regexp::GlushkovFirst::first ( indexedRegExp );
CPPUNIT_ASSERT ( first.size ( ) == 0 );
}
{
std::string input = "#E* a";
regexp::RegExp regexp = alib::StringDataFactory::fromString ( input );
- regexp::UnboundedRegExp < std::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( static_cast < const regexp::UnboundedRegExp < > & > ( regexp.getData ( ) ) );
+ regexp::UnboundedRegExp < ext::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( static_cast < const regexp::UnboundedRegExp < > & > ( regexp.getData ( ) ) );
- ext::set < regexp::UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > > first = regexp::GlushkovFirst::first ( indexedRegExp );
+ ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > > first = regexp::GlushkovFirst::first ( indexedRegExp );
CPPUNIT_ASSERT ( first.size ( ) == 1 );
}
@@ -49,18 +49,18 @@ void RegExpTest::testLast ( ) {
{
std::string input = "a+a";
regexp::RegExp regexp = alib::StringDataFactory::fromString ( input );
- regexp::UnboundedRegExp < std::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( static_cast < const regexp::UnboundedRegExp < > & > ( regexp.getData ( ) ) );
+ regexp::UnboundedRegExp < ext::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( static_cast < const regexp::UnboundedRegExp < > & > ( regexp.getData ( ) ) );
- ext::set < regexp::UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > > last = regexp::GlushkovLast::last ( indexedRegExp );
+ ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > > last = regexp::GlushkovLast::last ( indexedRegExp );
CPPUNIT_ASSERT ( last.size ( ) == 2 );
}
{
std::string input = "(a+a)b";
regexp::RegExp regexp = alib::StringDataFactory::fromString ( input );
- regexp::UnboundedRegExp < std::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( static_cast < const regexp::UnboundedRegExp < > & > ( regexp.getData ( ) ) );
+ regexp::UnboundedRegExp < ext::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( static_cast < const regexp::UnboundedRegExp < > & > ( regexp.getData ( ) ) );
- ext::set < regexp::UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > > last = regexp::GlushkovLast::last ( indexedRegExp );
+ ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > > last = regexp::GlushkovLast::last ( indexedRegExp );
std::cout << last << std::endl;
CPPUNIT_ASSERT ( last.size ( ) == 1 );
@@ -71,52 +71,52 @@ void RegExpTest::testFollow ( ) {
{
std::string input = "(a+a)b";
regexp::RegExp regexp = alib::StringDataFactory::fromString ( input );
- regexp::UnboundedRegExp < std::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( static_cast < const regexp::UnboundedRegExp < > & > ( regexp.getData ( ) ) );
+ regexp::UnboundedRegExp < ext::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( static_cast < const regexp::UnboundedRegExp < > & > ( regexp.getData ( ) ) );
auto symbolsIter = indexedRegExp.getAlphabet ( ).begin ( );
- ext::set < regexp::UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > > follow1 = regexp::GlushkovFollow::follow ( indexedRegExp, regexp::UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > ( * symbolsIter ) );
+ ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > > follow1 = regexp::GlushkovFollow::follow ( indexedRegExp, regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > ( * symbolsIter ) );
CPPUNIT_ASSERT ( follow1.size ( ) == 1 );
symbolsIter++;
- ext::set < regexp::UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > > follow2 = regexp::GlushkovFollow::follow ( indexedRegExp, regexp::UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > ( * symbolsIter ) );
+ ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > > follow2 = regexp::GlushkovFollow::follow ( indexedRegExp, regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > ( * symbolsIter ) );
CPPUNIT_ASSERT ( follow2.size ( ) == 1 );
symbolsIter++;
- ext::set < regexp::UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > > follow3 = regexp::GlushkovFollow::follow ( indexedRegExp, regexp::UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > ( * symbolsIter ) );
+ ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > > follow3 = regexp::GlushkovFollow::follow ( indexedRegExp, regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > ( * symbolsIter ) );
CPPUNIT_ASSERT ( follow3.size ( ) == 0 );
}
{
std::string input = "a+a* (b+a)* c";
regexp::RegExp regexp = alib::StringDataFactory::fromString ( input );
- regexp::UnboundedRegExp < std::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( static_cast < const regexp::UnboundedRegExp < > & > ( regexp.getData ( ) ) );
+ regexp::UnboundedRegExp < ext::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( static_cast < const regexp::UnboundedRegExp < > & > ( regexp.getData ( ) ) );
auto symbolsIter = indexedRegExp.getAlphabet ( ).begin ( );
- ext::set < regexp::UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > > follow1 = regexp::GlushkovFollow::follow ( indexedRegExp, regexp::UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > ( * symbolsIter ) );
+ ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > > follow1 = regexp::GlushkovFollow::follow ( indexedRegExp, regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > ( * symbolsIter ) );
CPPUNIT_ASSERT ( follow1.size ( ) == 0 );
symbolsIter++;
- ext::set < regexp::UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > > follow2 = regexp::GlushkovFollow::follow ( indexedRegExp, regexp::UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > ( * symbolsIter ) );
+ ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > > follow2 = regexp::GlushkovFollow::follow ( indexedRegExp, regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > ( * symbolsIter ) );
CPPUNIT_ASSERT ( follow2.size ( ) == 4 );
symbolsIter++;
- ext::set < regexp::UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > > follow3 = regexp::GlushkovFollow::follow ( indexedRegExp, regexp::UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > ( * symbolsIter ) );
+ ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > > follow3 = regexp::GlushkovFollow::follow ( indexedRegExp, regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > ( * symbolsIter ) );
CPPUNIT_ASSERT ( follow3.size ( ) == 3 );
symbolsIter++;
- ext::set < regexp::UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > > follow4 = regexp::GlushkovFollow::follow ( indexedRegExp, regexp::UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > ( * symbolsIter ) );
+ ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > > follow4 = regexp::GlushkovFollow::follow ( indexedRegExp, regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > ( * symbolsIter ) );
CPPUNIT_ASSERT ( follow4.size ( ) == 3 );
symbolsIter++;
- ext::set < regexp::UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > > follow5 = regexp::GlushkovFollow::follow ( indexedRegExp, regexp::UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > ( * symbolsIter ) );
+ ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > > follow5 = regexp::GlushkovFollow::follow ( indexedRegExp, regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > ( * symbolsIter ) );
CPPUNIT_ASSERT ( follow5.size ( ) == 0 );
}
diff --git a/alib2algo_experimental/src/grammar/parsing/AbsorbTerminalSymbol.cpp b/alib2algo_experimental/src/grammar/parsing/AbsorbTerminalSymbol.cpp
index f74be8427617a1106bfd383c33efbf1ec7d5853e..92f29151b5e456b8a67098acb834240de76b8fc9 100644
--- a/alib2algo_experimental/src/grammar/parsing/AbsorbTerminalSymbol.cpp
+++ b/alib2algo_experimental/src/grammar/parsing/AbsorbTerminalSymbol.cpp
@@ -50,7 +50,7 @@ void AbsorbTerminalSymbol::absorbTerminalSymbol ( grammar::CFG < > & grammar, co
ext::map < DefaultSymbolType, DefaultSymbolType > nonterminalsPrimed; // terminal is fixed in particular calls
for ( const DefaultSymbolType & nonterminal : nonterminals ) {
- DefaultSymbolType newSymbol = common::createUnique ( DefaultSymbolType ( DefaultSymbolsPairType ( std::make_pair ( nonterminal, terminal ) ) ), res.getTerminalAlphabet ( ), res.getNonterminalAlphabet ( ) );
+ DefaultSymbolType newSymbol = common::createUnique ( DefaultSymbolType ( DefaultSymbolsPairType ( ext::make_pair ( nonterminal, terminal ) ) ), res.getTerminalAlphabet ( ), res.getNonterminalAlphabet ( ) );
res.addNonterminalSymbol ( newSymbol );
nonterminalsPrimed.insert ( std::make_pair ( nonterminal, newSymbol ) );
}
diff --git a/alib2algo_experimental/src/grammar/parsing/DeterministicLL1Grammar.cpp b/alib2algo_experimental/src/grammar/parsing/DeterministicLL1Grammar.cpp
index 5fa6eef91fe4c4f1e6ac63f73d14b9435394aea8..349679092c4acd858cc56b13f080c37442449523 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 ) {
- ext::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > > parseTable = LL1ParseTable::parseTable ( grammar );
+ ext::map < ext::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > > parseTable = LL1ParseTable::parseTable ( grammar );
bool deterministic = true;
- for ( const std::pair < const std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > > & elem : parseTable )
+ for ( const std::pair < const ext::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::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 < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > > & elem : parseTable ) {
+ for ( const std::pair < const ext::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::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 < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > > & elem : parseTable ) {
+ for ( const std::pair < const ext::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::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 3c090ff546de346619f89011c85c1dcac12386df..472b3f6fad0f1f741aa39a837ab0b65bb1bade7c 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 {
-ext::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::vector < DefaultSymbolType > > DeterministicLL1ParseTable::parseTable ( const ext::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > > & parseTable ) {
+ext::map < ext::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::vector < DefaultSymbolType > > DeterministicLL1ParseTable::parseTable ( const ext::map < ext::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > > & parseTable ) {
- for ( const std::pair < const std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > > & elem : parseTable )
+ for ( const std::pair < const ext::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > > & elem : parseTable )
if ( elem.second.size ( ) > 1 )
throw exception::CommonException ( "Cant handle conflict in epsilon" );
- ext::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::vector < DefaultSymbolType > > res;
+ ext::map < ext::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::vector < DefaultSymbolType > > res;
- for ( const std::pair < const std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > > & elem : parseTable )
+ for ( const std::pair < const ext::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::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 4b24791bec82ff50c163c2c7e61a23a9a10912cb..db91d7210663f849bb76d81be4a25f37fb247dad 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 ext::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::vector < DefaultSymbolType > > parseTable ( const ext::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > > & parseTable );
+ static ext::map < ext::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::vector < DefaultSymbolType > > parseTable ( const ext::map < ext::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > > & parseTable );
};
} /* namespace parsing */
diff --git a/alib2algo_experimental/src/grammar/parsing/First.cpp b/alib2algo_experimental/src/grammar/parsing/First.cpp
index a24385baa71cf66527f35d9d932549292e7f86df..0cb7718c5eb83c4840120d0da9f756312868fa77 100644
--- a/alib2algo_experimental/src/grammar/parsing/First.cpp
+++ b/alib2algo_experimental/src/grammar/parsing/First.cpp
@@ -93,7 +93,7 @@ ext::map < ext::vector < DefaultSymbolType >, ext::set < ext::variant < DefaultS
for ( const std::pair < const DefaultSymbolType, ext::set < ext::vector < DefaultSymbolType > > > & rule : grammar.getRawRules ( ) )
for ( const ext::vector < DefaultSymbolType > & rhs : rule.second )
- res.insert ( make_pair ( rhs, first ( grammar.getTerminalAlphabet ( ), grammar.getNonterminalAlphabet ( ), firstNt, rhs ) ) );
+ res.insert ( std::make_pair ( rhs, first ( grammar.getTerminalAlphabet ( ), grammar.getNonterminalAlphabet ( ), firstNt, rhs ) ) );
return res;
}
diff --git a/alib2algo_experimental/src/grammar/parsing/LL1ParseTable.cpp b/alib2algo_experimental/src/grammar/parsing/LL1ParseTable.cpp
index 6dd7092f129ba23e888669d154b1f7a3f33e6edd..9c04c5c6b5f1fd2231591686ead5410ff40db07c 100644
--- a/alib2algo_experimental/src/grammar/parsing/LL1ParseTable.cpp
+++ b/alib2algo_experimental/src/grammar/parsing/LL1ParseTable.cpp
@@ -25,8 +25,8 @@ namespace grammar {
namespace parsing {
template < class T >
-ext::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > > LL1ParseTable::parseTable ( const T & grammar ) {
- ext::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > > res;
+ext::map < ext::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > > LL1ParseTable::parseTable ( const T & grammar ) {
+ ext::map < ext::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > > res;
ext::map < ext::vector < DefaultSymbolType >, ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > first = First::first ( grammar );
ext::map < DefaultSymbolType, ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > follow = Follow::follow ( grammar );
@@ -38,12 +38,12 @@ ext::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >,
for ( const ext::variant < DefaultSymbolType, string::Epsilon < > > & firstElem : first[rhs] ) {
if ( firstElem.is < string::Epsilon < > > ( ) ) continue;
- res[std::make_pair ( firstElem, lhs )].insert ( rhs );
+ res [ ext::make_pair ( firstElem, lhs ) ].insert ( rhs );
}
if ( first[rhs].count ( string::Epsilon < >::EPSILON ) )
for ( const ext::variant < DefaultSymbolType, string::Epsilon < > > & followElem : follow[lhs] )
- res[std::make_pair ( followElem, lhs )].insert ( rhs );
+ res [ ext::make_pair ( followElem, lhs ) ].insert ( rhs );
}
}
@@ -51,17 +51,17 @@ ext::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >,
return res;
}
-auto LL1ParseTableCFG = registration::OverloadRegister < LL1ParseTable, ext::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > >, grammar::CFG < > > ( LL1ParseTable::parseTable );
-auto LL1ParseTableEpsilonFreeCFG = registration::OverloadRegister < LL1ParseTable, ext::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > >, grammar::EpsilonFreeCFG < > > ( LL1ParseTable::parseTable );
-auto LL1ParseTableGNF = registration::OverloadRegister < LL1ParseTable, ext::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > >, grammar::GNF < > > ( LL1ParseTable::parseTable );
-auto LL1ParseTableCNF = registration::OverloadRegister < LL1ParseTable, ext::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > >, grammar::CNF < > > ( LL1ParseTable::parseTable );
-auto LL1ParseTableLG = registration::OverloadRegister < LL1ParseTable, ext::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > >, grammar::LG < > > ( LL1ParseTable::parseTable );
-auto LL1ParseTableLeftLG = registration::OverloadRegister < LL1ParseTable, ext::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > >, grammar::LeftLG < > > ( LL1ParseTable::parseTable );
-auto LL1ParseTableLeftRG = registration::OverloadRegister < LL1ParseTable, ext::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > >, grammar::LeftRG < > > ( LL1ParseTable::parseTable );
-auto LL1ParseTableRightLG = registration::OverloadRegister < LL1ParseTable, ext::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > >, grammar::RightLG < > > ( LL1ParseTable::parseTable );
-auto LL1ParseTableRightRG = registration::OverloadRegister < LL1ParseTable, ext::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > >, grammar::RightRG < > > ( LL1ParseTable::parseTable );
-
-ext::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > > LL1ParseTable::parseTable ( const grammar::Grammar & grammar ) {
+auto LL1ParseTableCFG = registration::OverloadRegister < LL1ParseTable, ext::map < ext::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > >, grammar::CFG < > > ( LL1ParseTable::parseTable );
+auto LL1ParseTableEpsilonFreeCFG = registration::OverloadRegister < LL1ParseTable, ext::map < ext::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > >, grammar::EpsilonFreeCFG < > > ( LL1ParseTable::parseTable );
+auto LL1ParseTableGNF = registration::OverloadRegister < LL1ParseTable, ext::map < ext::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > >, grammar::GNF < > > ( LL1ParseTable::parseTable );
+auto LL1ParseTableCNF = registration::OverloadRegister < LL1ParseTable, ext::map < ext::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > >, grammar::CNF < > > ( LL1ParseTable::parseTable );
+auto LL1ParseTableLG = registration::OverloadRegister < LL1ParseTable, ext::map < ext::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > >, grammar::LG < > > ( LL1ParseTable::parseTable );
+auto LL1ParseTableLeftLG = registration::OverloadRegister < LL1ParseTable, ext::map < ext::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > >, grammar::LeftLG < > > ( LL1ParseTable::parseTable );
+auto LL1ParseTableLeftRG = registration::OverloadRegister < LL1ParseTable, ext::map < ext::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > >, grammar::LeftRG < > > ( LL1ParseTable::parseTable );
+auto LL1ParseTableRightLG = registration::OverloadRegister < LL1ParseTable, ext::map < ext::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > >, grammar::RightLG < > > ( LL1ParseTable::parseTable );
+auto LL1ParseTableRightRG = registration::OverloadRegister < LL1ParseTable, ext::map < ext::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > >, grammar::RightRG < > > ( LL1ParseTable::parseTable );
+
+ext::map < ext::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::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 b0eddc3e954eba5fdf7ffe1847e46ff73288f36c..af5d6ac199ef1478b2a5c72b6877a2a0353e0f87 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, ext::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > >, const grammar::GrammarBase & > {
+class LL1ParseTable : public alib::SingleDispatch < LL1ParseTable, ext::map < ext::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > >, const grammar::GrammarBase & > {
public:
template < class T >
- static ext::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > > parseTable ( const T & grammar );
+ static ext::map < ext::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > > parseTable ( const T & grammar );
- static ext::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > > parseTable ( const grammar::Grammar & grammar );
+ static ext::map < ext::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > > parseTable ( const grammar::Grammar & grammar );
};
diff --git a/alib2algo_experimental/src/grammar/parsing/LRParser.cpp b/alib2algo_experimental/src/grammar/parsing/LRParser.cpp
index 275157f7b38ddbb38df0718289fe2506178f5b99..c0a1c8a7d0676a3e1bfcb06dfe4d22a17a68781d 100644
--- a/alib2algo_experimental/src/grammar/parsing/LRParser.cpp
+++ b/alib2algo_experimental/src/grammar/parsing/LRParser.cpp
@@ -47,7 +47,7 @@ bool LRParser::parse ( LRActionTable actionTable, LRGotoTable gotoTable, Default
break;
case LRAction::Reduce: {
- std::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > reduceBy = actionIterator->second.second.get < std::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > > ( );
+ ext::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > reduceBy = actionIterator->second.second.get < ext::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > > ( );
for ( unsigned i = 0; i < reduceBy.second.size ( ); ++i ) {
states.pop ( );
}
diff --git a/alib2algo_experimental/src/grammar/parsing/SLR1ParseTable.cpp b/alib2algo_experimental/src/grammar/parsing/SLR1ParseTable.cpp
index 7cdff9b11a83afe96780574c83f8cb6c9fd074d8..a62e2e21de793b44becec6bbebdf2b657229467b 100644
--- a/alib2algo_experimental/src/grammar/parsing/SLR1ParseTable.cpp
+++ b/alib2algo_experimental/src/grammar/parsing/SLR1ParseTable.cpp
@@ -31,8 +31,8 @@ LRActionTable SLR1ParseTable::getActionTable ( grammar::CFG < > originalGrammar
automaton::DFA<> parsingAutomaton = LR0Parser::getAutomaton ( originalGrammar );
for ( const DefaultStateType & state : parsingAutomaton.getStates ( ) ) {
LR0Items items = static_cast < const label::LR0ItemsLabel & > ( state . getData ( ) ) . getItems ( );
- ext::range < ext::map < std::pair < DefaultStateType, DefaultSymbolType >, DefaultStateType >::const_iterator > transitionsFromCurrentStateRange = parsingAutomaton.getTransitionsFromState ( state );
- ext::map < std::pair < DefaultStateType, DefaultSymbolType >, DefaultStateType > transitionsFromCurrentState ( transitionsFromCurrentStateRange.begin ( ), transitionsFromCurrentStateRange.end ( ) );
+ ext::range < ext::map < ext::pair < DefaultStateType, DefaultSymbolType >, DefaultStateType >::const_iterator > transitionsFromCurrentStateRange = parsingAutomaton.getTransitionsFromState ( state );
+ ext::map < ext::pair < DefaultStateType, DefaultSymbolType >, DefaultStateType > transitionsFromCurrentState ( transitionsFromCurrentStateRange.begin ( ), transitionsFromCurrentStateRange.end ( ) );
for ( const LR0Items::value_type & nonterminalItems : items ) {
DefaultSymbolType leftHandSide = nonterminalItems.first;
for ( const std::pair < unsigned, ext::vector < DefaultSymbolType > > & item : nonterminalItems.second ) {
@@ -46,7 +46,7 @@ LRActionTable SLR1ParseTable::getActionTable ( grammar::CFG < > originalGrammar
}
grammar::parsing::FollowResult2 followSet = grammar::parsing::Follow::follow ( augmentedGrammar, leftHandSide );
- std::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > currentRule = { leftHandSide, rightHandSide };
+ ext::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > currentRule = { leftHandSide, rightHandSide };
for ( const ext::variant < DefaultSymbolType, string::Epsilon < > > & followSymbol : followSet ) {
if ( followSymbol.is < DefaultSymbolType > ( ) ) {
insertToActionTable(actionTable, { state, followSymbol.get < DefaultSymbolType > ( ) }, { LRAction::Reduce, currentRule } );
@@ -73,10 +73,10 @@ LRGotoTable SLR1ParseTable::getGotoTable ( grammar::CFG < > originalGrammar ) {
grammar::CFG < > augmentedGrammar = LRParser::getAugmentedGrammar ( originalGrammar );
automaton::DFA<> parsingAutomaton = LR0Parser::getAutomaton ( originalGrammar );
for ( const DefaultStateType & state : parsingAutomaton.getStates ( ) ) {
- ext::range < ext::map < std::pair < DefaultStateType, DefaultSymbolType >, DefaultStateType >::const_iterator > transitionsFromCurrentStateRange = parsingAutomaton.getTransitionsFromState ( state );
- ext::map < std::pair < DefaultStateType, DefaultSymbolType >, DefaultStateType > transitionsFromCurrentState ( transitionsFromCurrentStateRange.begin ( ), transitionsFromCurrentStateRange.end ( ) );
+ ext::range < ext::map < ext::pair < DefaultStateType, DefaultSymbolType >, DefaultStateType >::const_iterator > transitionsFromCurrentStateRange = parsingAutomaton.getTransitionsFromState ( state );
+ ext::map < ext::pair < DefaultStateType, DefaultSymbolType >, DefaultStateType > transitionsFromCurrentState ( transitionsFromCurrentStateRange.begin ( ), transitionsFromCurrentStateRange.end ( ) );
for ( const DefaultSymbolType & nonterminal : augmentedGrammar.getNonterminalAlphabet ( ) ) {
- ext::map < std::pair<DefaultStateType, DefaultSymbolType >, DefaultStateType >::iterator transitionIterator = transitionsFromCurrentState.find ( { state, nonterminal } );
+ ext::map < ext::pair<DefaultStateType, DefaultSymbolType >, DefaultStateType >::iterator transitionIterator = transitionsFromCurrentState.find ( { state, nonterminal } );
if ( transitionIterator != transitionsFromCurrentState.end ( ) ) {
gotoTable.insert ( { { state, nonterminal }, transitionIterator->second } );
}
diff --git a/alib2algo_experimental/test-src/grammar/parsing/AbsorbTerminalSymbol.cpp b/alib2algo_experimental/test-src/grammar/parsing/AbsorbTerminalSymbol.cpp
index 788901b67512a34c0dfa92e65ec840fe37874b66..bfa82da272cc6c3cf894c69d6b57cdfe90c8d684 100644
--- a/alib2algo_experimental/test-src/grammar/parsing/AbsorbTerminalSymbol.cpp
+++ b/alib2algo_experimental/test-src/grammar/parsing/AbsorbTerminalSymbol.cpp
@@ -23,7 +23,7 @@ void AbsorbTerminalSymbol::testAbsorbTerminalSymbol ( ) {
DefaultSymbolType b = DefaultSymbolType ( 'b' );
DefaultSymbolType c = DefaultSymbolType ( 'c' );
- DefaultSymbolType Ba = DefaultSymbolType ( DefaultSymbolsPairType ( std::make_pair ( B, a ) ) );
+ DefaultSymbolType Ba = DefaultSymbolType ( DefaultSymbolsPairType ( ext::make_pair ( B, a ) ) );
grammar::CFG < > grammar ( A );
@@ -69,8 +69,8 @@ void AbsorbTerminalSymbol::testAbsorbTerminalSymbol2 ( ) {
DefaultSymbolType b = DefaultSymbolType ( 'b' );
DefaultSymbolType c = DefaultSymbolType ( 'c' );
- DefaultSymbolType Ba = DefaultSymbolType ( DefaultSymbolsPairType ( std::make_pair ( B, a ) ) );
- DefaultSymbolType Xa = DefaultSymbolType ( DefaultSymbolsPairType ( std::make_pair ( X, a ) ) );
+ DefaultSymbolType Ba = DefaultSymbolType ( DefaultSymbolsPairType ( ext::make_pair ( B, a ) ) );
+ DefaultSymbolType Xa = DefaultSymbolType ( DefaultSymbolsPairType ( ext::make_pair ( X, a ) ) );
grammar::CFG < > grammar ( A );
@@ -118,7 +118,7 @@ void AbsorbTerminalSymbol::testAbsorbTerminalSymbol3 ( ) {
DefaultSymbolType b = DefaultSymbolType ( 'b' );
DefaultSymbolType c = DefaultSymbolType ( 'c' );
- DefaultSymbolType Ba = DefaultSymbolType ( DefaultSymbolsPairType ( std::make_pair ( B, a ) ) );
+ DefaultSymbolType Ba = DefaultSymbolType ( DefaultSymbolsPairType ( ext::make_pair ( B, a ) ) );
grammar::CFG < > grammar ( A );
diff --git a/alib2algo_experimental/test-src/grammar/parsing/HandleFirstFollowConflict.cpp b/alib2algo_experimental/test-src/grammar/parsing/HandleFirstFollowConflict.cpp
index dd7b1da63770ffdc476067f6c4d70cc2a47a2c94..cd1ca80f58790e73e51d9d8750fae69317e09d93 100644
--- a/alib2algo_experimental/test-src/grammar/parsing/HandleFirstFollowConflict.cpp
+++ b/alib2algo_experimental/test-src/grammar/parsing/HandleFirstFollowConflict.cpp
@@ -24,7 +24,7 @@ void HandleFirstFollowConflict::testHandleFirstFollowConflict ( ) {
DefaultSymbolType c = DefaultSymbolType ( 'c' );
DefaultSymbolType d = DefaultSymbolType ( 'd' );
- DefaultSymbolType Ba = DefaultSymbolType ( DefaultSymbolsPairType ( std::make_pair ( B, a ) ) );
+ DefaultSymbolType Ba = DefaultSymbolType ( DefaultSymbolsPairType ( ext::make_pair ( B, a ) ) );
grammar::CFG < > grammar ( A );
@@ -94,8 +94,8 @@ void HandleFirstFollowConflict::testHandleFirstFollowConflict2 ( ) {
DefaultSymbolType c = DefaultSymbolType ( 'c' );
DefaultSymbolType d = DefaultSymbolType ( 'd' );
- DefaultSymbolType Ba = DefaultSymbolType ( DefaultSymbolsPairType ( std::make_pair ( B, a ) ) );
- DefaultSymbolType Xa = DefaultSymbolType ( DefaultSymbolsPairType ( std::make_pair ( X, a ) ) );
+ DefaultSymbolType Ba = DefaultSymbolType ( DefaultSymbolsPairType ( ext::make_pair ( B, a ) ) );
+ DefaultSymbolType Xa = DefaultSymbolType ( DefaultSymbolsPairType ( ext::make_pair ( X, a ) ) );
grammar::CFG < > grammar ( A );
diff --git a/alib2algo_experimental/test-src/grammar/parsing/LL1ParseTable.cpp b/alib2algo_experimental/test-src/grammar/parsing/LL1ParseTable.cpp
index 157d3aded4591ea128271c73e2ae11be3f53d239..8806d31612631201603c7564066d0f594218a285 100644
--- a/alib2algo_experimental/test-src/grammar/parsing/LL1ParseTable.cpp
+++ b/alib2algo_experimental/test-src/grammar/parsing/LL1ParseTable.cpp
@@ -50,29 +50,29 @@ void LL1ParseTable::testLL1Table ( ) {
grammar.addRule ( nF, rhsF2 );
// --------------------------------------------------
- ext::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > > parseTable;
+ ext::map < ext::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > > parseTable;
- parseTable[std::make_pair ( tA, nE )].insert ( rhsE1 );
- parseTable[std::make_pair ( tL, nE )].insert ( rhsE1 );
+ parseTable[ext::make_pair ( tA, nE )].insert ( rhsE1 );
+ parseTable[ext::make_pair ( tL, nE )].insert ( rhsE1 );
- parseTable[std::make_pair ( tP, nEp )].insert ( rhsEp1 );
- parseTable[std::make_pair ( tR, nEp )].insert ( rhsEp2 );
- parseTable[std::make_pair ( string::Epsilon < >::EPSILON, nEp )].insert ( rhsEp2 );
+ parseTable[ext::make_pair ( tP, nEp )].insert ( rhsEp1 );
+ parseTable[ext::make_pair ( tR, nEp )].insert ( rhsEp2 );
+ parseTable[ext::make_pair ( string::Epsilon < >::EPSILON, nEp )].insert ( rhsEp2 );
- parseTable[std::make_pair ( tA, nT )].insert ( rhsT1 );
- parseTable[std::make_pair ( tL, nT )].insert ( rhsT1 );
+ parseTable[ext::make_pair ( tA, nT )].insert ( rhsT1 );
+ parseTable[ext::make_pair ( tL, nT )].insert ( rhsT1 );
- parseTable[std::make_pair ( tS, nTp )].insert ( rhsTp1 );
- parseTable[std::make_pair ( tP, nTp )].insert ( rhsTp2 );
- parseTable[std::make_pair ( tR, nTp )].insert ( rhsTp2 );
- parseTable[std::make_pair ( string::Epsilon < >::EPSILON, nTp )].insert ( rhsTp2 );
+ parseTable[ext::make_pair ( tS, nTp )].insert ( rhsTp1 );
+ parseTable[ext::make_pair ( tP, nTp )].insert ( rhsTp2 );
+ parseTable[ext::make_pair ( tR, nTp )].insert ( rhsTp2 );
+ parseTable[ext::make_pair ( string::Epsilon < >::EPSILON, nTp )].insert ( rhsTp2 );
- parseTable[std::make_pair ( tA, nF )].insert ( rhsF1 );
- parseTable[std::make_pair ( tL, nF )].insert ( rhsF2 );
+ parseTable[ext::make_pair ( tA, nF )].insert ( rhsF1 );
+ parseTable[ext::make_pair ( tL, nF )].insert ( rhsF2 );
// --------------------------------------------------
- ext::map < std::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > > parseTableAlgo = grammar::parsing::LL1ParseTable::parseTable ( grammar );
+ ext::map < ext::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < DefaultSymbolType > > > parseTableAlgo = grammar::parsing::LL1ParseTable::parseTable ( grammar );
std::cout << parseTable << std::endl;
std::cout << parseTableAlgo << std::endl;
diff --git a/alib2algo_experimental/test-src/grammar/parsing/SLR1ParseTable.cpp b/alib2algo_experimental/test-src/grammar/parsing/SLR1ParseTable.cpp
index b78333607a7ccbb63eafba3578a30815829720f5..5f9709bd4f29755aef42d5a2dd08daaf789287c7 100644
--- a/alib2algo_experimental/test-src/grammar/parsing/SLR1ParseTable.cpp
+++ b/alib2algo_experimental/test-src/grammar/parsing/SLR1ParseTable.cpp
@@ -252,35 +252,35 @@ void SLR1ParseTable::testActionTable ( ) {
{ { states[9], times }, { grammar::parsing::LRAction::Shift, states[7] } }
};
- std::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > reduceBy = { E, { T } };
+ ext::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > reduceBy = ext::make_pair ( E, ext::vector < DefaultSymbolType > { T } );
correctActionTable.insert ( { { states[2], plus }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
correctActionTable.insert ( { { states[2], rightParenthesis }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
correctActionTable.insert ( { { states[2], endOfInput }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
- reduceBy = { T, { F } };
+ reduceBy = ext::make_pair ( T, ext::vector < DefaultSymbolType > { F } );
correctActionTable.insert ( { { states[3], plus }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
correctActionTable.insert ( { { states[3], times }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
correctActionTable.insert ( { { states[3], rightParenthesis }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
correctActionTable.insert ( { { states[3], endOfInput }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
- reduceBy = { F, { identifier } };
+ reduceBy = ext::make_pair ( F, ext::vector < DefaultSymbolType > { identifier } );
correctActionTable.insert ( { { states[5], plus }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
correctActionTable.insert ( { { states[5], times }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
correctActionTable.insert ( { { states[5], rightParenthesis }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
correctActionTable.insert ( { { states[5], endOfInput }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
- reduceBy = { E, { E, plus, T } };
+ reduceBy = ext::make_pair ( E, ext::vector < DefaultSymbolType > { E, plus, T } );
correctActionTable.insert ( { { states[9], plus }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
correctActionTable.insert ( { { states[9], rightParenthesis }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
correctActionTable.insert ( { { states[9], endOfInput }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
- reduceBy = { T, { T, times, F } };
+ reduceBy = ext::make_pair ( T, ext::vector < DefaultSymbolType > { T, times, F } );
correctActionTable.insert ( { { states[10], plus }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
correctActionTable.insert ( { { states[10], times }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
correctActionTable.insert ( { { states[10], rightParenthesis }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
correctActionTable.insert ( { { states[10], endOfInput }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
- reduceBy = { F, { leftParenthesis, E, rightParenthesis } };
+ reduceBy = ext::make_pair ( F, ext::vector < DefaultSymbolType > { leftParenthesis, E, rightParenthesis } );
correctActionTable.insert ( { { states[11], plus }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
correctActionTable.insert ( { { states[11], times }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
correctActionTable.insert ( { { states[11], rightParenthesis }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
@@ -310,7 +310,7 @@ void SLR1ParseTable::testActionTable ( ) {
break;
case grammar::parsing::LRAction::Reduce:
- if ( actionTablePair.second.second.get < std::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > > ( ) != value->second.second.get < std::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > > ( ) ) {
+ if ( actionTablePair.second.second.get < ext::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > > ( ) != value->second.second.get < ext::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > > ( ) ) {
correctContent = false;
}
break;
diff --git a/alib2common/src/container/ObjectsMap.h b/alib2common/src/container/ObjectsMap.h
index 703a09aad220fbdc823cf3098462a9152d3d14cc..a1d09007ffcaa47e111bc7846712da6fe2a6fd91 100644
--- a/alib2common/src/container/ObjectsMap.h
+++ b/alib2common/src/container/ObjectsMap.h
@@ -133,7 +133,7 @@ ext::map < KeyType, ValueType > ObjectsMap < KeyType, ValueType >::parseRaw ( ex
ext::map < KeyType, ValueType > map;
while ( sax::FromXMLParserHelper::isTokenType ( input, sax::Token::TokenType::START_ELEMENT ) )
- map.insert ( alib::xmlApi < std::pair < KeyType, ValueType > >::parse ( input ) );
+ map.insert ( alib::xmlApi < ext::pair < KeyType, ValueType > >::parse ( input ) );
sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, ObjectsMap < >::getXmlTagName() );
return map;
@@ -144,7 +144,7 @@ void ObjectsMap < KeyType, ValueType >::compose ( ext::deque < sax::Token > & ou
out.emplace_back ( ObjectsMap < >::getXmlTagName(), sax::Token::TokenType::START_ELEMENT );
for ( const std::pair < const KeyType, ValueType > & item : input )
- alib::xmlApi < std::pair < const KeyType, ValueType > >::compose ( out, item );
+ alib::xmlApi < ext::pair < const KeyType, ValueType > >::compose ( out, item );
out.emplace_back ( ObjectsMap < >::getXmlTagName(), sax::Token::TokenType::END_ELEMENT );
}
diff --git a/alib2common/src/container/ObjectsPair.h b/alib2common/src/container/ObjectsPair.h
index 9aa76ee3dc191ea447de37eb6f61cc0e4730e204..b6282cc376a8f08975141e2c645a92125fa669fd 100644
--- a/alib2common/src/container/ObjectsPair.h
+++ b/alib2common/src/container/ObjectsPair.h
@@ -26,10 +26,10 @@ namespace container {
* Contains reason why the container occured.
*/
template < class FirstType, class SecondType >
-class ObjectsPair final : public std::pair < FirstType, SecondType >, public ContainerBase {
+class ObjectsPair final : public ext::pair < FirstType, SecondType >, public ContainerBase {
public:
explicit ObjectsPair ( FirstType firstObject, SecondType secondObject );
- explicit ObjectsPair ( std::pair < FirstType, SecondType > );
+ explicit ObjectsPair ( ext::pair < FirstType, SecondType > );
virtual ContainerBase * clone ( ) const;
@@ -54,13 +54,18 @@ public:
}
static ObjectsPair parse ( ext::deque < sax::Token >::iterator & input );
- static std::pair < FirstType, SecondType > parseRaw ( ext::deque < sax::Token >::iterator & input );
+ static ext::pair < FirstType, SecondType > parseRaw ( ext::deque < sax::Token >::iterator & input );
void compose ( ext::deque < sax::Token > & out ) const;
static void compose ( ext::deque < sax::Token > & out, const std::pair < FirstType, SecondType > & input );
+ static void compose ( ext::deque < sax::Token > & out, const ext::pair < FirstType, SecondType > & input );
virtual alib::ObjectBase * inc ( ) &&;
+ static ext::pair < alib::Object, alib::Object > normalizeRaw ( ext::pair < FirstType, SecondType > && source ) {
+ return ext::make_pair ( alib::Object ( alib::AnyObject < FirstType > ( std::move ( source.first ) ) ), alib::Object ( alib::AnyObject < SecondType > ( std::move ( source.second ) ) ) );
+ }
+
static std::pair < alib::Object, alib::Object > normalizeRaw ( std::pair < FirstType, SecondType > && source ) {
return std::make_pair ( alib::Object ( alib::AnyObject < FirstType > ( std::move ( source.first ) ) ), alib::Object ( alib::AnyObject < SecondType > ( std::move ( source.second ) ) ) );
}
@@ -73,12 +78,12 @@ public:
};
template < class FirstType, class SecondType >
-ObjectsPair < FirstType, SecondType >::ObjectsPair(std::pair<FirstType, SecondType> raw) : std::pair<FirstType, SecondType>(std::move(raw)) {
+ObjectsPair < FirstType, SecondType >::ObjectsPair(ext::pair<FirstType, SecondType> raw) : ext::pair<FirstType, SecondType>(std::move(raw)) {
}
template < class FirstType, class SecondType >
-ObjectsPair < FirstType, SecondType >::ObjectsPair(FirstType firstObject, SecondType secondObject) : std::pair<FirstType, SecondType>(std::move(firstObject), std::move(secondObject)) {
+ObjectsPair < FirstType, SecondType >::ObjectsPair(FirstType firstObject, SecondType secondObject) : ext::pair<FirstType, SecondType>(std::move(firstObject), std::move(secondObject)) {
}
@@ -94,13 +99,13 @@ ContainerBase* ObjectsPair < FirstType, SecondType >::plunder() && {
template < class FirstType, class SecondType >
int ObjectsPair < FirstType, SecondType >::compare(const ObjectsPair& other) const {
- static ext::compare<std::pair<FirstType, SecondType>> comp;
- return comp ( static_cast < const std::pair < FirstType, SecondType > & > ( * this ), static_cast < const std::pair < FirstType, SecondType > & > ( other ) );
+ static ext::compare<ext::pair<FirstType, SecondType>> comp;
+ return comp ( static_cast < const ext::pair < FirstType, SecondType > & > ( * this ), static_cast < const ext::pair < FirstType, SecondType > & > ( other ) );
}
template < class FirstType, class SecondType >
void ObjectsPair < FirstType, SecondType >::operator>>(std::ostream& os) const {
- os << "(ObjectsPair " << static_cast < const std::pair < FirstType, SecondType > & > ( * this ) << ")";
+ os << "(ObjectsPair " << static_cast < const ext::pair < FirstType, SecondType > & > ( * this ) << ")";
}
template < class FirstType, class SecondType >
@@ -121,7 +126,7 @@ void ObjectsPair < FirstType, SecondType >::compose(ext::deque<sax::Token>& out)
}
template < class FirstType, class SecondType >
-std::pair < FirstType, SecondType > ObjectsPair < FirstType, SecondType >::parseRaw ( ext::deque < sax::Token >::iterator & input ) {
+ext::pair < FirstType, SecondType > ObjectsPair < FirstType, SecondType >::parseRaw ( ext::deque < sax::Token >::iterator & input ) {
sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, ObjectsPair::getXmlTagName() );
FirstType first = alib::xmlApi < FirstType >::parse ( input );
@@ -129,7 +134,7 @@ std::pair < FirstType, SecondType > ObjectsPair < FirstType, SecondType >::parse
sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, ObjectsPair::getXmlTagName() );
- return std::make_pair ( std::move ( first ), std::move ( second ) );
+ return ext::make_pair ( std::move ( first ), std::move ( second ) );
}
template < class FirstType, class SecondType >
@@ -142,6 +147,11 @@ void ObjectsPair < FirstType, SecondType >::compose ( ext::deque < sax::Token >
out.emplace_back ( ObjectsPair::getXmlTagName(), sax::Token::TokenType::END_ELEMENT );
}
+template < class FirstType, class SecondType >
+void ObjectsPair < FirstType, SecondType >::compose ( ext::deque < sax::Token > & out, const ext::pair < FirstType, SecondType > & input ) {
+ compose ( out, static_cast < const std::pair < FirstType, SecondType > & > ( input ) );
+}
+
template < class FirstType, class SecondType >
alib::ObjectBase* ObjectsPair < FirstType, SecondType >::inc() && {
return new alib::UniqueObject(alib::Object(std::move(*this)), primitive::Integer(0));
@@ -152,30 +162,36 @@ alib::ObjectBase* ObjectsPair < FirstType, SecondType >::inc() && {
namespace alib {
template < typename T, typename R >
-struct xmlApi < std::pair < T, R > > {
- static std::pair < T, R > parse ( ext::deque < sax::Token >::iterator & input );
+struct xmlApi < ext::pair < T, R > > {
+ static ext::pair < T, R > parse ( ext::deque < sax::Token >::iterator & input );
static bool first ( const ext::deque < sax::Token >::const_iterator & input );
static std::string xmlTagName ( );
+ static void compose ( ext::deque < sax::Token > & output, const ext::pair < T, R > & data );
static void compose ( ext::deque < sax::Token > & output, const std::pair < T, R > & data );
};
template < typename T, typename R >
-std::pair < T, R > xmlApi < std::pair < T, R > >::parse ( ext::deque < sax::Token >::iterator & input ) {
+ext::pair < T, R > xmlApi < ext::pair < T, R > >::parse ( ext::deque < sax::Token >::iterator & input ) {
return container::ObjectsPair < T, R >::parseRaw ( input );
}
template < typename T, typename R >
-bool xmlApi < std::pair < T, R > >::first ( const ext::deque < sax::Token >::const_iterator & input ) {
+bool xmlApi < ext::pair < T, R > >::first ( const ext::deque < sax::Token >::const_iterator & input ) {
return sax::FromXMLParserHelper::isToken ( input, sax::Token::TokenType::START_ELEMENT, xmlTagName() );
}
template < typename T, typename R >
-std::string xmlApi < std::pair < T, R > >::xmlTagName ( ) {
+std::string xmlApi < ext::pair < T, R > >::xmlTagName ( ) {
return container::ObjectsPair < >::getXmlTagName();
}
template < typename T, typename R >
-void xmlApi < std::pair < T, R > >::compose ( ext::deque < sax::Token > & output, const std::pair < T, R > & input ) {
+void xmlApi < ext::pair < T, R > >::compose ( ext::deque < sax::Token > & output, const ext::pair < T, R > & input ) {
+ return container::ObjectsPair < T, R >::compose ( output, input );
+}
+
+template < typename T, typename R >
+void xmlApi < ext::pair < T, R > >::compose ( ext::deque < sax::Token > & output, const std::pair < T, R > & input ) {
return container::ObjectsPair < T, R >::compose ( output, input );
}
diff --git a/alib2common/src/object/Object.cpp b/alib2common/src/object/Object.cpp
index 8347e7b0df7bcc43934e57a4e8c5cd916ea1a8f1..33aad69593735b8b0a6804fceb982685f76b60e7 100644
--- a/alib2common/src/object/Object.cpp
+++ b/alib2common/src/object/Object.cpp
@@ -24,7 +24,7 @@ Object::Object ( int number ) : alib::WrapperBase < ObjectBase > ( primitive::In
Object::Object ( int number1, int number2 ) : Object ( Object { primitive::Integer ( number1 ) }, Object { primitive::Integer ( number2 ) } ) {
}
-Object::Object ( Object object1, Object object2 ) : alib::WrapperBase < ObjectBase > ( container::ObjectsPair < Object, Object > { std::make_pair ( std::move ( object1 ), std::move ( object2 ) ) } ) {
+Object::Object ( Object object1, Object object2 ) : alib::WrapperBase < ObjectBase > ( container::ObjectsPair < Object, Object > { ext::make_pair ( std::move ( object1 ), std::move ( object2 ) ) } ) {
}
Object::Object ( char character ) : alib::WrapperBase < ObjectBase > ( primitive::Character ( character ) ) {
diff --git a/alib2common/test-src/object/AnyObjectTest.cpp b/alib2common/test-src/object/AnyObjectTest.cpp
index 2cda69f099d77bf015c30e424528af20c03daed0..8a7602cd462befab84eb8a769fd6565a8ce1fc7a 100644
--- a/alib2common/test-src/object/AnyObjectTest.cpp
+++ b/alib2common/test-src/object/AnyObjectTest.cpp
@@ -21,7 +21,7 @@ void AnyObjectTest::tearDown ( ) {
void AnyObjectTest::testXMLParser ( ) {
- alib::AnyObject < std::pair < int, char > > object ( std::make_pair ( 1, 'a' ) );
+ alib::AnyObject < ext::pair < int, char > > object ( ext::make_pair ( 1, 'a' ) );
alib::Object res ( container::ObjectsPair < alib::Object, alib::Object > ( alib::Object ( primitive::Integer ( 1 ) ), alib::Object ( primitive::Character ( 'a' ) ) ) );
{
diff --git a/alib2data/src/automaton/FSM/CompactNFA.h b/alib2data/src/automaton/FSM/CompactNFA.h
index cb3a96c6bf3e9ed1fc0033432688390df6017c00..19c866b4f407da2ad81e0bdcb1a608130d1c1eeb 100644
--- a/alib2data/src/automaton/FSM/CompactNFA.h
+++ b/alib2data/src/automaton/FSM/CompactNFA.h
@@ -42,7 +42,7 @@ class InitialState;
template < class SymbolType, class StateType >
class CompactNFA final : public AutomatonBase, public alib::Components < CompactNFA < SymbolType, StateType >, SymbolType, ext::tuple < InputAlphabet >, ext::tuple < >, StateType, ext::tuple < States, FinalStates >, ext::tuple < InitialState > > {
protected:
- ext::map < std::pair < StateType, ext::vector < SymbolType > >, ext::set < StateType > > transitions;
+ ext::map < ext::pair < StateType, ext::vector < SymbolType > >, ext::set < StateType > > transitions;
public:
explicit CompactNFA ( StateType initialState );
@@ -145,17 +145,17 @@ public:
/**
* @return automaton transitions
*/
- const ext::map < std::pair < StateType, ext::vector < SymbolType > >, ext::set < StateType > > & getTransitions ( ) const;
+ const ext::map < ext::pair < StateType, ext::vector < SymbolType > >, ext::set < StateType > > & getTransitions ( ) const;
/**
* @return automaton transitions from state
*/
- ext::map < std::pair < StateType, ext::vector < SymbolType > >, ext::set < StateType > > getTransitionsFromState ( const StateType & from ) const;
+ ext::map < ext::pair < StateType, ext::vector < SymbolType > >, ext::set < StateType > > getTransitionsFromState ( const StateType & from ) const;
/**
* @return automaton transitions to state
*/
- ext::map < std::pair < StateType, ext::vector < SymbolType > >, ext::set < StateType > > getTransitionsToState ( const StateType & from ) const;
+ ext::map < ext::pair < StateType, ext::vector < SymbolType > >, ext::set < StateType > > 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 );
@@ -196,7 +196,7 @@ public:
CompactNFA < > * res = new CompactNFA < > ( std::move ( states ), std::move ( alphabet ), std::move ( initialState ), std::move ( finalStates ) );
- for ( std::pair < std::pair < StateType, ext::vector < SymbolType > >, ext::set < StateType > > && transition : ext::make_moveable_map ( transitions ) ) {
+ for ( std::pair < ext::pair < StateType, ext::vector < SymbolType > >, ext::set < StateType > > && transition : ext::make_moveable_map ( transitions ) ) {
DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) );
ext::vector < DefaultSymbolType > input = alphabet::SymbolNormalize::normalizeSymbols ( std::move ( transition.first.second ) );
ext::set < DefaultStateType > targets = AutomatonNormalize::normalizeStates ( std::move ( transition.second ) );
@@ -230,10 +230,10 @@ template < class EpsilonType >
CompactNFA < SymbolType, StateType >::CompactNFA ( const EpsilonNFA < SymbolType, EpsilonType, StateType > & other ) : CompactNFA ( other.getStates ( ), other.getInputAlphabet ( ), other.getInitialState ( ), other.getFinalStates ( ) ) {
for ( const auto & transition : other.getTransitions ( ) ) {
if ( transition.first.second.template is < EpsilonType > ( ) ) {
- std::pair < StateType, ext::vector < SymbolType > > key = std::make_pair ( transition.first.first, ext::vector < SymbolType > { } );
+ ext::pair < StateType, ext::vector < SymbolType > > key = ext::make_pair ( transition.first.first, ext::vector < SymbolType > { } );
transitions[key] = transition.second;
} else {
- std::pair < StateType, ext::vector < SymbolType > > key = std::make_pair ( transition.first.first, ext::vector < SymbolType > { transition.first.second.template get < SymbolType > ( ) } );
+ ext::pair < StateType, ext::vector < SymbolType > > key = ext::make_pair ( transition.first.first, ext::vector < SymbolType > { transition.first.second.template get < SymbolType > ( ) } );
transitions[key] = transition.second;
}
}
@@ -242,18 +242,18 @@ CompactNFA < SymbolType, StateType >::CompactNFA ( const EpsilonNFA < SymbolType
template < class SymbolType, class StateType >
CompactNFA < SymbolType, StateType >::CompactNFA ( const MultiInitialStateNFA < SymbolType, StateType > & other ) : CompactNFA ( other.getStates ( ) + ext::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, ext::vector < SymbolType > > key = std::make_pair ( transition.first.first, ext::vector < SymbolType > { transition.first.second } );
+ ext::pair < StateType, ext::vector < SymbolType > > key = ext::make_pair ( transition.first.first, ext::vector < SymbolType > { transition.first.second } );
transitions[key] = transition.second;
}
- std::pair < StateType, ext::vector < SymbolType > > key = std::make_pair ( this->getInitialState ( ), ext::vector < SymbolType > { } );
+ ext::pair < StateType, ext::vector < SymbolType > > key = ext::make_pair ( this->getInitialState ( ), ext::vector < SymbolType > { } );
transitions[key] = other.getInitialStates ( );
}
template < class SymbolType, class StateType >
CompactNFA < SymbolType, StateType >::CompactNFA ( const NFA < SymbolType, StateType > & other ) : CompactNFA ( other.getStates ( ), other.getInputAlphabet ( ), other.getInitialState ( ), other.getFinalStates ( ) ) {
for ( const auto & transition : other.getTransitions ( ) ) {
- std::pair < StateType, ext::vector < SymbolType > > key = std::make_pair ( transition.first.first, ext::vector < SymbolType > { transition.first.second } );
+ ext::pair < StateType, ext::vector < SymbolType > > key = ext::make_pair ( transition.first.first, ext::vector < SymbolType > { transition.first.second } );
transitions[key] = transition.second;
}
}
@@ -261,7 +261,7 @@ CompactNFA < SymbolType, StateType >::CompactNFA ( const NFA < SymbolType, State
template < class SymbolType, class StateType >
CompactNFA < SymbolType, StateType >::CompactNFA ( const DFA < SymbolType, StateType > & other ) : CompactNFA ( other.getStates ( ), other.getInputAlphabet ( ), other.getInitialState ( ), other.getFinalStates ( ) ) {
for ( const auto & transition : other.getTransitions ( ) ) {
- std::pair < StateType, ext::vector < SymbolType > > key = std::make_pair ( transition.first.first, ext::vector < SymbolType > { transition.first.second } );
+ ext::pair < StateType, ext::vector < SymbolType > > key = ext::make_pair ( transition.first.first, ext::vector < SymbolType > { transition.first.second } );
transitions[key].insert ( transition.second );
}
}
@@ -290,7 +290,7 @@ bool CompactNFA < SymbolType, StateType >::addTransition ( StateType from, ext::
if ( !getStates ( ).count ( to ) )
throw AutomatonException ( "State \"" + ext::to_string ( to ) + "\" doesn't exist." );
- std::pair < StateType, ext::vector < SymbolType > > key = std::make_pair ( std::move ( from ), std::move ( input ) );
+ ext::pair < StateType, ext::vector < SymbolType > > key = ext::make_pair ( std::move ( from ), std::move ( input ) );
return transitions[std::move ( key )].insert ( std::move ( to ) ).second;
}
@@ -309,47 +309,47 @@ void CompactNFA < SymbolType, StateType >::addTransitions ( StateType from, ext:
if ( !std::includes ( getStates ( ).begin ( ), getStates ( ).end ( ), to.begin ( ), to.end ( ) ) )
throw AutomatonException ( "Some target states don't exist." );
- std::pair < StateType, ext::vector < SymbolType > > key = std::make_pair ( std::move ( from ), std::move ( input ) );
+ ext::pair < StateType, ext::vector < SymbolType > > key = ext::make_pair ( std::move ( from ), std::move ( input ) );
transitions [ std::move ( key ) ].insert ( ext::make_moveable_set ( to ).begin ( ), ext::make_moveable_set ( to ).end ( ) );
}
template < class SymbolType, class StateType >
bool CompactNFA < SymbolType, StateType >::removeTransition ( const StateType & from, const ext::vector < SymbolType > & input, const StateType & to ) {
- std::pair < StateType, ext::vector < SymbolType > > key = std::make_pair ( from, input );
+ ext::pair < StateType, ext::vector < SymbolType > > key = std::make_pair ( from, input );
return transitions[key].erase ( to );
}
template < class SymbolType, class StateType >
-const ext::map < std::pair < StateType, ext::vector < SymbolType > >, ext::set < StateType > > & CompactNFA < SymbolType, StateType >::getTransitions ( ) const {
+const ext::map < ext::pair < StateType, ext::vector < SymbolType > >, ext::set < StateType > > & CompactNFA < SymbolType, StateType >::getTransitions ( ) const {
return transitions;
}
template < class SymbolType, class StateType >
-ext::map < std::pair < StateType, ext::vector < SymbolType > >, ext::set < StateType > > CompactNFA < SymbolType, StateType >::getTransitionsFromState ( const StateType & from ) const {
+ext::map < ext::pair < StateType, ext::vector < SymbolType > >, ext::set < StateType > > CompactNFA < SymbolType, StateType >::getTransitionsFromState ( const StateType & from ) const {
if ( !getStates ( ).count ( from ) )
throw AutomatonException ( "State \"" + ext::to_string ( from ) + "\" doesn't exist" );
- ext::map < std::pair < StateType, ext::vector < SymbolType > >, ext::set < StateType > > transitionsFromState;
+ ext::map < ext::pair < StateType, ext::vector < SymbolType > >, ext::set < StateType > > transitionsFromState;
- for ( const std::pair < const std::pair < StateType, ext::vector < SymbolType > >, ext::set < StateType > > & transition : transitions )
+ for ( const std::pair < const ext::pair < StateType, ext::vector < SymbolType > >, ext::set < StateType > > & transition : transitions )
if ( transition.first.first == from )
- transitionsFromState.insert ( make_pair ( transition.first, transition.second ) );
+ transitionsFromState.insert ( std::make_pair ( transition.first, transition.second ) );
return transitionsFromState;
}
template < class SymbolType, class StateType >
-ext::map < std::pair < StateType, ext::vector < SymbolType > >, ext::set < StateType > > CompactNFA < SymbolType, StateType >::getTransitionsToState ( const StateType & to ) const {
+ext::map < ext::pair < StateType, ext::vector < SymbolType > >, ext::set < StateType > > CompactNFA < SymbolType, StateType >::getTransitionsToState ( const StateType & to ) const {
if ( !getStates ( ).count ( to ) )
throw AutomatonException ( "State \"" + ext::to_string ( to ) + "\" doesn't exist" );
- ext::map < std::pair < StateType, ext::vector < SymbolType > >, ext::set < StateType > > transitionsToState;
+ ext::map < ext::pair < StateType, ext::vector < SymbolType > >, ext::set < StateType > > transitionsToState;
- for ( const std::pair < const std::pair < StateType, ext::vector < SymbolType > >, ext::set < StateType > > & transition : transitions )
+ for ( const std::pair < const ext::pair < StateType, ext::vector < SymbolType > >, ext::set < StateType > > & transition : transitions )
if ( transition.second.find ( to ) != transition.second.end ( ) )
- transitionsToState.insert ( make_pair ( transition.first, transition.second ) );
+ transitionsToState.insert ( std::make_pair ( transition.first, transition.second ) );
return transitionsToState;
}
@@ -458,7 +458,7 @@ template < class SymbolType, class StateType >
class ComponentConstraint< automaton::CompactNFA < SymbolType, StateType >, SymbolType, automaton::InputAlphabet > {
public:
static bool used ( const automaton::CompactNFA < SymbolType, StateType > & automaton, const SymbolType & symbol ) {
- for ( const std::pair < const std::pair < StateType, ext::vector < SymbolType > >, ext::set < StateType > > & transition : automaton.getTransitions ( ) ) {
+ for ( const std::pair < const ext::pair < StateType, ext::vector < SymbolType > >, ext::set < StateType > > & transition : automaton.getTransitions ( ) ) {
ext::set < SymbolType > alphabet ( transition.first.second.begin ( ), transition.first.second.end ( ) );
if ( alphabet.count ( symbol ) )
return true;
@@ -485,7 +485,7 @@ public:
if ( automaton.getFinalStates ( ).count ( state ) )
return true;
- for ( const std::pair < const std::pair < StateType, ext::vector < SymbolType > >, ext::set < StateType > > & t : automaton.getTransitions ( ) )
+ for ( const std::pair < const ext::pair < StateType, ext::vector < SymbolType > >, ext::set < StateType > > & t : automaton.getTransitions ( ) )
if ( ( t.first.first == state ) || t.second.count ( state ) )
return true;
diff --git a/alib2data/src/automaton/FSM/DFA.h b/alib2data/src/automaton/FSM/DFA.h
index 0d3447e0cff15617b77eeb97d90dafb0f9db40cd..966555271789c9419c6b305c305413ed14803cb8 100644
--- a/alib2data/src/automaton/FSM/DFA.h
+++ b/alib2data/src/automaton/FSM/DFA.h
@@ -39,7 +39,7 @@ class InitialState;
template<class SymbolType, class StateType >
class DFA final : public AutomatonBase, public alib::Components < DFA < SymbolType, StateType >, SymbolType, ext::tuple < InputAlphabet >, ext::tuple < >, StateType, ext::tuple < States, FinalStates >, ext::tuple < InitialState > > {
protected:
- ext::map < std::pair < StateType, SymbolType >, StateType > transitions;
+ ext::map < ext::pair < StateType, SymbolType >, StateType > transitions;
public:
explicit DFA ( StateType initialState );
@@ -128,17 +128,17 @@ public:
/**
* @return automaton transitions
*/
- const ext::map < std::pair < StateType, SymbolType >, StateType > & getTransitions ( ) const;
+ const ext::map < ext::pair < StateType, SymbolType >, StateType > & getTransitions ( ) const;
/**
* @return automaton transitions from state
*/
- ext::range < typename ext::map < std::pair < StateType, SymbolType >, StateType >::const_iterator > getTransitionsFromState ( const StateType & from ) const;
+ ext::range < typename ext::map < ext::pair < StateType, SymbolType >, StateType >::const_iterator > getTransitionsFromState ( const StateType & from ) const;
/**
* @return automaton transitions to state
*/
- ext::map < std::pair < StateType, SymbolType >, StateType > getTransitionsToState ( const StateType & from ) const;
+ ext::map < ext::pair < StateType, SymbolType >, StateType > getTransitionsToState ( const StateType & from ) const;
/**
* Determines whether DFA is total deterministic
@@ -188,7 +188,7 @@ public:
DFA < > * res = new DFA < > ( std::move ( states ), std::move ( alphabet ), std::move ( initialState ), std::move ( finalStates ) );
- for ( std::pair < std::pair < StateType, SymbolType >, StateType > && transition : ext::make_moveable_map ( transitions ) ) {
+ for ( std::pair < ext::pair < StateType, SymbolType >, StateType > && transition : ext::make_moveable_map ( transitions ) ) {
DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) );
DefaultSymbolType input = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( transition.first.second ) );
DefaultStateType to = AutomatonNormalize::normalizeState ( std::move ( transition.second ) );
@@ -229,7 +229,7 @@ bool DFA<SymbolType, StateType>::addTransition ( StateType from, SymbolType inpu
if ( !getStates ( ).count ( to ) )
throw AutomatonException ( "State \"" + ext::to_string ( to ) + "\" doesn't exist." );
- std::pair < StateType, SymbolType > key = std::make_pair ( std::move ( from ), std::move ( input ) );
+ ext::pair < StateType, SymbolType > key = ext::make_pair ( std::move ( from ), std::move ( input ) );
if ( transitions.find ( key ) != transitions.end ( ) ) {
if ( transitions.find ( key )->second == to )
@@ -244,7 +244,7 @@ bool DFA<SymbolType, StateType>::addTransition ( StateType from, SymbolType inpu
template<class SymbolType, class StateType >
bool DFA<SymbolType, StateType>::removeTransition ( const StateType & from, const SymbolType & input, const StateType & to ) {
- std::pair < StateType, SymbolType > key = std::make_pair ( from, input );
+ ext::pair < StateType, SymbolType > key = ext::make_pair ( from, input );
if ( transitions.find ( key ) == transitions.end ( ) )
return false;
@@ -257,7 +257,7 @@ bool DFA<SymbolType, StateType>::removeTransition ( const StateType & from, cons
}
template<class SymbolType, class StateType >
-const ext::map < std::pair < StateType, SymbolType >, StateType > & DFA<SymbolType, StateType>::getTransitions ( ) const {
+const ext::map < ext::pair < StateType, SymbolType >, StateType > & DFA<SymbolType, StateType>::getTransitions ( ) const {
return transitions;
}
@@ -281,15 +281,15 @@ const ext::map < std::pair < StateType, SymbolType >, StateType > & DFA<SymbolTy
};
template<class SymbolType, class StateType >
-ext::range < typename ext::map < std::pair < StateType, SymbolType >, StateType >::const_iterator > DFA<SymbolType, StateType>::getTransitionsFromState ( const StateType & from ) const {
+ext::range < typename ext::map < ext::pair < StateType, SymbolType >, StateType >::const_iterator > DFA<SymbolType, StateType>::getTransitionsFromState ( const StateType & from ) const {
if ( !getStates ( ).count ( from ) )
throw AutomatonException ( "State \"" + ext::to_string ( from ) + "\" doesn't exist" );
- typename ext::map < std::pair < StateType, SymbolType >, StateType >::const_iterator lower = transitions.begin ( );
+ typename ext::map < ext::pair < StateType, SymbolType >, StateType >::const_iterator lower = transitions.begin ( );
while ( lower != transitions.end ( ) && lower->first.first < from ) {
++ lower;
}
- typename ext::map < std::pair < StateType, SymbolType >, StateType >::const_iterator upper = transitions.begin ( );
+ typename ext::map < ext::pair < StateType, SymbolType >, StateType >::const_iterator upper = transitions.begin ( );
while ( upper != transitions.end ( ) && upper->first.first <= from ) {
++ upper;
}
@@ -298,13 +298,13 @@ ext::range < typename ext::map < std::pair < StateType, SymbolType >, StateType
}
template<class SymbolType, class StateType >
-ext::map < std::pair < StateType, SymbolType >, StateType > DFA<SymbolType, StateType>::getTransitionsToState ( const StateType & to ) const {
+ext::map < ext::pair < StateType, SymbolType >, StateType > DFA<SymbolType, StateType>::getTransitionsToState ( const StateType & to ) const {
if ( !getStates ( ).count ( to ) )
throw AutomatonException ( "State \"" + ext::to_string ( to ) + "\" doesn't exist" );
- ext::map < std::pair < StateType, SymbolType >, StateType > transitionsToState;
+ ext::map < ext::pair < StateType, SymbolType >, StateType > transitionsToState;
- for ( const std::pair < const std::pair < StateType, SymbolType >, StateType > & transition : transitions )
+ for ( const std::pair < const ext::pair < StateType, SymbolType >, StateType > & transition : transitions )
if ( transition.second == to )
transitionsToState.insert ( transition );
@@ -419,7 +419,7 @@ template<class SymbolType, class StateType >
class ComponentConstraint< automaton::DFA<SymbolType, StateType>, SymbolType, automaton::InputAlphabet > {
public:
static bool used ( const automaton::DFA<SymbolType, StateType> & automaton, const SymbolType & symbol ) {
- for ( const std::pair < const std::pair < StateType, SymbolType >, StateType > & transition : automaton.getTransitions ( ) )
+ for ( const std::pair < const ext::pair < StateType, SymbolType >, StateType > & transition : automaton.getTransitions ( ) )
if ( transition.first.second == symbol )
return true;
@@ -445,7 +445,7 @@ public:
if ( automaton.getFinalStates ( ).count ( state ) )
return true;
- for ( const std::pair < const std::pair < StateType, SymbolType >, StateType > & t : automaton.getTransitions ( ) )
+ for ( const std::pair < const ext::pair < StateType, SymbolType >, StateType > & t : automaton.getTransitions ( ) )
if ( ( t.first.first == state ) || ( t.second == state ) )
return true;
diff --git a/alib2data/src/automaton/FSM/EpsilonNFA.h b/alib2data/src/automaton/FSM/EpsilonNFA.h
index fe099666ec3e3d14d58c20273bb850edcb0a1000..e6c7631c70e7b03a9a79d0fbfdced9c9c750b53f 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, ext::tuple < InputAlphabet >, ext::tuple < >, StateType, ext::tuple < States, FinalStates >, ext::tuple < InitialState > > {
protected:
- ext::map < std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::set < StateType > > transitions;
+ ext::map < ext::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::set < StateType > > transitions;
public:
explicit EpsilonNFA ( StateType initialState );
@@ -184,7 +184,7 @@ public:
/**
* @return automaton transitions
*/
- const ext::map < std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::set < StateType > > & getTransitions ( ) const;
+ const ext::map < ext::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::set < StateType > > & getTransitions ( ) const;
/**
* @return automaton epsilon transitions
@@ -194,12 +194,12 @@ public:
/**
* @return automaton transitions reading some symbol
*/
- ext::map < std::pair < StateType, SymbolType >, ext::set < StateType > > getSymbolTransitions ( ) const;
+ ext::map < ext::pair < StateType, SymbolType >, ext::set < StateType > > getSymbolTransitions ( ) const;
/**
* @return automaton transitions from state
*/
- ext::map < std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::set < StateType > > getTransitionsFromState ( const StateType & from ) const;
+ ext::map < ext::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::set < StateType > > getTransitionsFromState ( const StateType & from ) const;
/**
* @return automaton epsilon transitions from state
@@ -209,12 +209,12 @@ public:
/**
* @return automaton transitions from state reading some symbols
*/
- ext::map < std::pair < StateType, SymbolType >, ext::set < StateType > > getSymbolTransitionsFromState ( const StateType & from ) const;
+ ext::map < ext::pair < StateType, SymbolType >, ext::set < StateType > > getSymbolTransitionsFromState ( const StateType & from ) const;
/**
* @return automaton transitions to state
*/
- ext::map < std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::set < StateType > > getTransitionsToState ( const StateType & from ) const;
+ ext::map < ext::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::set < StateType > > getTransitionsToState ( const StateType & from ) const;
/**
* @return automaton epsilon transitions to state
@@ -224,7 +224,7 @@ public:
/**
* @return automaton transitions to state reading some symbols
*/
- ext::map < std::pair < StateType, SymbolType >, ext::set < StateType > > getSymbolTransitionsToState ( const StateType & to ) const;
+ ext::map < ext::pair < StateType, SymbolType >, ext::set < StateType > > getSymbolTransitionsToState ( const StateType & to ) const;
/**
* Determines whether NFA is without epsilon transitions.
@@ -289,7 +289,7 @@ public:
EpsilonNFA < > * res = new EpsilonNFA < > ( std::move ( states ), std::move ( alphabet ), std::move ( initialState ), std::move ( finalStates ) );
- for ( std::pair < std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::set < StateType > > && transition : ext::make_moveable_map ( transitions ) ) {
+ for ( std::pair < ext::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::set < StateType > > && transition : ext::make_moveable_map ( transitions ) ) {
DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) );
ext::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( transition.first.second ) );
ext::set < DefaultStateType > targets = AutomatonNormalize::normalizeStates ( std::move ( transition.second ) );
@@ -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 ( ) + ext::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, ext::variant < EpsilonType, SymbolType > > key = std::make_pair ( transition.first.first, ext::variant < EpsilonType, SymbolType > ( transition.first.second ) );
+ ext::pair < StateType, ext::variant < EpsilonType, SymbolType > > key = ext::make_pair ( transition.first.first, ext::variant < EpsilonType, SymbolType > ( transition.first.second ) );
transitions[key] = transition.second;
}
- std::pair < StateType, ext::variant < EpsilonType, SymbolType > > key = std::make_pair ( getInitialState ( ), ext::variant < EpsilonType, SymbolType >::template from < EpsilonType > ( ) );
+ ext::pair < StateType, ext::variant < EpsilonType, SymbolType > > key = ext::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, ext::variant < EpsilonType, SymbolType > > key = std::make_pair ( transition.first.first, ext::variant < EpsilonType, SymbolType > ( transition.first.second ) );
+ ext::pair < StateType, ext::variant < EpsilonType, SymbolType > > key = ext::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, ext::variant < EpsilonType, SymbolType > > key = std::make_pair ( transition.first.first, ext::variant < EpsilonType, SymbolType > ( transition.first.second ) );
+ ext::pair < StateType, ext::variant < EpsilonType, SymbolType > > key = ext::make_pair ( transition.first.first, ext::variant < EpsilonType, SymbolType > ( transition.first.second ) );
transitions[key].insert ( transition.second );
}
}
@@ -367,7 +367,7 @@ bool EpsilonNFA < SymbolType, EpsilonType, StateType >::addTransition ( StateTyp
if ( !getStates ( ).count ( to ) )
throw AutomatonException ( "State \"" + ext::to_string ( to ) + "\" doesn't exist." );
- std::pair < StateType, ext::variant < EpsilonType, SymbolType > > key = std::make_pair ( std::move ( from ), std::move ( input ) );
+ ext::pair < StateType, ext::variant < EpsilonType, SymbolType > > key = ext::make_pair ( std::move ( from ), std::move ( input ) );
return transitions[std::move ( key )].insert ( std::move ( to ) ).second;
}
@@ -397,7 +397,7 @@ 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, ext::variant < EpsilonType, SymbolType > > key = std::make_pair ( std::move ( from ), std::move ( input ) );
+ ext::pair < StateType, ext::variant < EpsilonType, SymbolType > > key = ext::make_pair ( std::move ( from ), std::move ( input ) );
transitions [ std::move ( key ) ].insert ( ext::make_moveable_set ( to ).begin ( ), ext::make_moveable_set ( to ).end ( ) );
}
@@ -419,7 +419,7 @@ void EpsilonNFA < SymbolType, EpsilonType, StateType >::addTransitions ( StateTy
template<class SymbolType, class EpsilonType, class StateType >
bool EpsilonNFA < SymbolType, EpsilonType, StateType >::removeTransition ( const StateType & from, const SymbolType & input, const StateType & to ) {
ext::variant < EpsilonType, SymbolType > inputVariant ( input );
- std::pair < StateType, ext::variant < EpsilonType, SymbolType > > key = std::make_pair ( from, inputVariant );
+ ext::pair < StateType, ext::variant < EpsilonType, SymbolType > > key = ext::make_pair ( from, inputVariant );
return transitions[key].erase ( to );
}
@@ -428,13 +428,13 @@ template<class SymbolType, class EpsilonType, class StateType >
bool EpsilonNFA < SymbolType, EpsilonType, StateType >::removeTransition ( const StateType & from, const StateType & to ) {
auto inputVariant = ext::variant < EpsilonType, SymbolType >::template from < EpsilonType > ( );
- std::pair < StateType, ext::variant < EpsilonType, SymbolType > > key = std::make_pair ( from, inputVariant );
+ ext::pair < StateType, ext::variant < EpsilonType, SymbolType > > key = ext::make_pair ( from, inputVariant );
return transitions[key].erase ( to );
}
template<class SymbolType, class EpsilonType, class StateType >
-const ext::map < std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::set < StateType > > & EpsilonNFA < SymbolType, EpsilonType, StateType >::getTransitions ( ) const {
+const ext::map < ext::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::set < StateType > > & EpsilonNFA < SymbolType, EpsilonType, StateType >::getTransitions ( ) const {
return transitions;
}
@@ -442,7 +442,7 @@ template<class SymbolType, class EpsilonType, class StateType >
ext::map < StateType, ext::set < StateType > > EpsilonNFA < SymbolType, EpsilonType, StateType >::getEpsilonTransitions ( ) const {
ext::map < StateType, ext::set < StateType > > result;
- for ( const std::pair < const std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::set < StateType > > & transition : transitions )
+ for ( const std::pair < const ext::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::set < StateType > > & transition : transitions )
if ( transition.first.second.template is < EpsilonType > ( ) )
result[transition.first.first].insert ( transition.second.begin ( ), transition.second.end ( ) );
@@ -450,24 +450,24 @@ ext::map < StateType, ext::set < StateType > > EpsilonNFA < SymbolType, EpsilonT
}
template<class SymbolType, class EpsilonType, class StateType >
-ext::map < std::pair < StateType, SymbolType >, ext::set < StateType > > EpsilonNFA < SymbolType, EpsilonType, StateType >::getSymbolTransitions ( ) const {
- ext::map < std::pair < StateType, SymbolType >, ext::set < StateType > > result;
+ext::map < ext::pair < StateType, SymbolType >, ext::set < StateType > > EpsilonNFA < SymbolType, EpsilonType, StateType >::getSymbolTransitions ( ) const {
+ ext::map < ext::pair < StateType, SymbolType >, ext::set < StateType > > result;
- for ( const std::pair < const std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::set < StateType > > & transition : transitions )
+ for ( const std::pair < const ext::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::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 ( ) );
+ result[ext::pair < StateType, SymbolType > ( transition.first.first, transition.first.second.template get < SymbolType > ( ) )].insert ( transition.second.begin ( ), transition.second.end ( ) );
return result;
}
template<class SymbolType, class EpsilonType, class StateType >
-ext::map < std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::set < StateType > > EpsilonNFA < SymbolType, EpsilonType, StateType >::getTransitionsFromState ( const StateType & from ) const {
+ext::map < ext::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::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" );
- ext::map < std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::set < StateType > > transitionsFromState;
+ ext::map < ext::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::set < StateType > > transitionsFromState;
- for ( const std::pair < const std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::set < StateType > > & transition : transitions )
+ for ( const std::pair < const ext::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::set < StateType > > & transition : transitions )
if ( transition.first.first == from )
transitionsFromState[transition.first].insert ( transition.second.begin ( ), transition.second.end ( ) );
@@ -479,7 +479,7 @@ ext::map < StateType, ext::set < StateType > > EpsilonNFA < SymbolType, EpsilonT
if ( !getStates ( ).count ( from ) )
throw AutomatonException ( "State \"" + ext::to_string ( from ) + "\" doesn't exist" );
- std::pair < StateType, ext::variant < EpsilonType, SymbolType > > key ( from, ext::variant < EpsilonType, SymbolType >::template from < EpsilonType > ( ) );
+ ext::pair < StateType, ext::variant < EpsilonType, SymbolType > > key ( from, ext::variant < EpsilonType, SymbolType >::template from < EpsilonType > ( ) );
ext::map < StateType, ext::set < StateType > > res;
auto transition = transitions.find ( key );
@@ -490,27 +490,27 @@ ext::map < StateType, ext::set < StateType > > EpsilonNFA < SymbolType, EpsilonT
}
template<class SymbolType, class EpsilonType, class StateType >
-ext::map < std::pair < StateType, SymbolType >, ext::set < StateType > > EpsilonNFA < SymbolType, EpsilonType, StateType >::getSymbolTransitionsFromState ( const StateType & from ) const {
+ext::map < ext::pair < StateType, SymbolType >, ext::set < StateType > > EpsilonNFA < SymbolType, EpsilonType, StateType >::getSymbolTransitionsFromState ( const StateType & from ) const {
if ( !getStates ( ).count ( from ) )
throw AutomatonException ( "State \"" + ext::to_string ( from ) + "\" doesn't exist" );
- ext::map < std::pair < StateType, SymbolType >, ext::set < StateType > > transitionsFromState;
+ ext::map < ext::pair < StateType, SymbolType >, ext::set < StateType > > transitionsFromState;
- for ( const std::pair < const std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::set < StateType > > & transition : transitions )
+ for ( const std::pair < const ext::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::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 ( ) );
+ transitionsFromState[ext::pair < StateType, SymbolType > ( transition.first.first, transition.first.second.template get < SymbolType > ( ) )].insert ( transition.second.begin ( ), transition.second.end ( ) );
return transitionsFromState;
}
template<class SymbolType, class EpsilonType, class StateType >
-ext::map < std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::set < StateType > > EpsilonNFA < SymbolType, EpsilonType, StateType >::getTransitionsToState ( const StateType & to ) const {
+ext::map < ext::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::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" );
- ext::map < std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::set < StateType > > transitionsToState;
+ ext::map < ext::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::set < StateType > > transitionsToState;
- for ( const std::pair < const std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::set < StateType > > & transition : transitions )
+ for ( const std::pair < const ext::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::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 @@ ext::map < StateType, ext::set < StateType > > EpsilonNFA < SymbolType, EpsilonT
ext::map < StateType, ext::set < StateType > > transitionsToState;
- for ( const std::pair < const std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::set < StateType > > & transition : transitions )
+ for ( const std::pair < const ext::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::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 ( ) );
@@ -532,22 +532,22 @@ ext::map < StateType, ext::set < StateType > > EpsilonNFA < SymbolType, EpsilonT
}
template<class SymbolType, class EpsilonType, class StateType >
-ext::map < std::pair < StateType, SymbolType >, ext::set < StateType > > EpsilonNFA < SymbolType, EpsilonType, StateType >::getSymbolTransitionsToState ( const StateType & to ) const {
+ext::map < ext::pair < StateType, SymbolType >, ext::set < StateType > > EpsilonNFA < SymbolType, EpsilonType, StateType >::getSymbolTransitionsToState ( const StateType & to ) const {
if ( !getStates ( ).count ( to ) )
throw AutomatonException ( "State \"" + ext::to_string ( to ) + "\" doesn't exist" );
- ext::map < std::pair < StateType, SymbolType >, ext::set < StateType > > transitionsToState;
+ ext::map < ext::pair < StateType, SymbolType >, ext::set < StateType > > transitionsToState;
- for ( const std::pair < const std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::set < StateType > > & transition : transitions )
+ for ( const std::pair < const ext::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::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 ( ) );
+ transitionsToState[ext::pair < StateType, SymbolType > ( transition.first.first, transition.first.second.template get < SymbolType > ( ) )].insert ( transition.second.begin ( ), transition.second.end ( ) );
return transitionsToState;
}
template<class SymbolType, class EpsilonType, class StateType >
bool EpsilonNFA < SymbolType, EpsilonType, StateType >::isEpsilonFree ( ) const {
- for ( const std::pair < const std::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::set < StateType > > & transition : transitions )
+ for ( const std::pair < const ext::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::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, ext::variant < EpsilonType, SymbolType > >, ext::set < StateType > > & transition : transitions )
+ for ( const std::pair < const ext::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::set < StateType > > & transition : transitions )
if ( transition.second.size ( ) > 1 )
return false;
@@ -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, ext::variant < EpsilonType, SymbolType > >, ext::set < StateType > > & transition : automaton.getTransitions ( ) )
+ for ( const std::pair < const ext::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::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, ext::variant < EpsilonType, SymbolType > >, ext::set < StateType > > & transition : automaton.getTransitions ( ) )
+ for ( const std::pair < const ext::pair < StateType, ext::variant < EpsilonType, SymbolType > >, ext::set < StateType > > & transition : automaton.getTransitions ( ) )
if ( ( transition.first.first == state ) || transition.second.count ( state ) )
return true;
diff --git a/alib2data/src/automaton/FSM/ExtendedNFA.h b/alib2data/src/automaton/FSM/ExtendedNFA.h
index 12e1508c9e0ce7d8ef461e2ce24ebff716c4fe77..24fb17a703b2b81b9fdece8a69dad801e56e9f0f 100644
--- a/alib2data/src/automaton/FSM/ExtendedNFA.h
+++ b/alib2data/src/automaton/FSM/ExtendedNFA.h
@@ -45,7 +45,7 @@ class InitialState;
template<class SymbolType, class StateType >
class ExtendedNFA final : public AutomatonBase, public alib::Components < ExtendedNFA < SymbolType, StateType >, SymbolType, ext::tuple < InputAlphabet >, ext::tuple < >, StateType, ext::tuple < States, FinalStates >, ext::tuple < InitialState > > {
protected:
- ext::map < std::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > >, ext::set < StateType > > transitions;
+ ext::map < ext::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > >, ext::set < StateType > > transitions;
public:
explicit ExtendedNFA ( StateType initialState );
@@ -149,17 +149,17 @@ public:
/**
* @return automaton transitions
*/
- const ext::map < std::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > >, ext::set < StateType > > & getTransitions ( ) const;
+ const ext::map < ext::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > >, ext::set < StateType > > & getTransitions ( ) const;
/**
* @return automaton transitions from state
*/
- ext::map < std::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > >, ext::set < StateType > > getTransitionsFromState ( const StateType & from ) const;
+ ext::map < ext::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > >, ext::set < StateType > > getTransitionsFromState ( const StateType & from ) const;
/**
* @return automaton transitions to state
*/
- ext::map < std::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > >, ext::set < StateType > > getTransitionsToState ( const StateType & from ) const;
+ ext::map < ext::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > >, ext::set < StateType > > 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 );
@@ -200,7 +200,7 @@ public:
ExtendedNFA < > * res = new ExtendedNFA < > ( std::move ( states ), std::move ( alphabet ), std::move ( initialState ), std::move ( finalStates ) );
- for ( std::pair < std::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > >, ext::set < StateType > > && transition : ext::make_moveable_map ( transitions ) ) {
+ for ( std::pair < ext::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > >, ext::set < StateType > > && transition : ext::make_moveable_map ( transitions ) ) {
DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) );
regexp::UnboundedRegExpStructure < DefaultSymbolType > input = AutomatonNormalize::normalizeRegExp ( std::move ( transition.first.second ) );
ext::set < DefaultStateType > targets = AutomatonNormalize::normalizeStates ( std::move ( transition.second ) );
@@ -238,7 +238,7 @@ ExtendedNFA < SymbolType, StateType >::ExtendedNFA ( const CompactNFA < SymbolTy
for ( auto & symbol : transition.first.second )
con.appendElement ( regexp::UnboundedRegExpSymbol < SymbolType > ( symbol ) );
- std::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > > key = std::make_pair ( transition.first.first, regexp::UnboundedRegExpStructure < SymbolType > ( std::move ( con ) ) );
+ ext::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > > key = ext::make_pair ( transition.first.first, regexp::UnboundedRegExpStructure < SymbolType > ( std::move ( con ) ) );
transitions[key] = transition.second;
}
}
@@ -248,10 +248,10 @@ template < class EpsilonType >
ExtendedNFA < SymbolType, StateType >::ExtendedNFA ( const EpsilonNFA < SymbolType, EpsilonType, StateType > & other ) : ExtendedNFA ( other.getStates ( ), other.getInputAlphabet ( ), other.getInitialState ( ), other.getFinalStates ( ) ) {
for ( const auto & transition : other.getTransitions ( ) ) {
if ( transition.first.second.template is < EpsilonType > ( ) ) {
- std::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > > key = std::make_pair ( transition.first.first, regexp::UnboundedRegExpStructure < SymbolType > ( ) );
+ ext::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > > key = ext::make_pair ( transition.first.first, regexp::UnboundedRegExpStructure < SymbolType > ( ) );
transitions[key] = transition.second;
} else {
- std::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > > key = std::make_pair ( transition.first.first, regexp::UnboundedRegExpStructure < SymbolType > ( regexp::UnboundedRegExpSymbol < SymbolType > ( transition.first.second.template get < SymbolType > ( ) ) ) );
+ ext::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > > key = ext::make_pair ( transition.first.first, regexp::UnboundedRegExpStructure < SymbolType > ( regexp::UnboundedRegExpSymbol < SymbolType > ( transition.first.second.template get < SymbolType > ( ) ) ) );
transitions[key] = transition.second;
}
}
@@ -260,18 +260,18 @@ ExtendedNFA < SymbolType, StateType >::ExtendedNFA ( const EpsilonNFA < SymbolTy
template<class SymbolType, class StateType >
ExtendedNFA < SymbolType, StateType >::ExtendedNFA ( const MultiInitialStateNFA < SymbolType, StateType > & other ) : ExtendedNFA ( other.getStates ( ) + ext::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, regexp::UnboundedRegExpStructure < SymbolType > > key = std::make_pair ( transition.first.first, regexp::UnboundedRegExpStructure < SymbolType > ( regexp::UnboundedRegExpSymbol < SymbolType > ( transition.first.second ) ) );
+ ext::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > > key = ext::make_pair ( transition.first.first, regexp::UnboundedRegExpStructure < SymbolType > ( regexp::UnboundedRegExpSymbol < SymbolType > ( transition.first.second ) ) );
transitions[key] = transition.second;
}
- std::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > > key = std::make_pair ( this->getInitialState ( ), regexp::UnboundedRegExpStructure < SymbolType > ( ) );
+ ext::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > > key = ext::make_pair ( this->getInitialState ( ), regexp::UnboundedRegExpStructure < SymbolType > ( ) );
transitions[key] = other.getInitialStates ( );
}
template<class SymbolType, class StateType >
ExtendedNFA < SymbolType, StateType >::ExtendedNFA ( const NFA < SymbolType, StateType > & other ) : ExtendedNFA ( other.getStates ( ), other.getInputAlphabet ( ), other.getInitialState ( ), other.getFinalStates ( ) ) {
for ( const auto & transition : other.getTransitions ( ) ) {
- std::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > > key = std::make_pair ( transition.first.first, regexp::UnboundedRegExpStructure < SymbolType > ( regexp::UnboundedRegExpSymbol < SymbolType > ( transition.first.second ) ) );
+ ext::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > > key = ext::make_pair ( transition.first.first, regexp::UnboundedRegExpStructure < SymbolType > ( regexp::UnboundedRegExpSymbol < SymbolType > ( transition.first.second ) ) );
transitions[key] = transition.second;
}
}
@@ -279,7 +279,7 @@ ExtendedNFA < SymbolType, StateType >::ExtendedNFA ( const NFA < SymbolType, Sta
template<class SymbolType, class StateType >
ExtendedNFA < SymbolType, StateType >::ExtendedNFA ( const DFA < SymbolType, StateType > & other ) : ExtendedNFA ( other.getStates ( ), other.getInputAlphabet ( ), other.getInitialState ( ), other.getFinalStates ( ) ) {
for ( const auto & transition : other.getTransitions ( ) ) {
- std::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > > key = std::make_pair ( transition.first.first, regexp::UnboundedRegExpStructure < SymbolType > ( regexp::UnboundedRegExpSymbol < SymbolType > ( transition.first.second ) ) );
+ ext::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > > key = ext::make_pair ( transition.first.first, regexp::UnboundedRegExpStructure < SymbolType > ( regexp::UnboundedRegExpSymbol < SymbolType > ( transition.first.second ) ) );
transitions[key].insert ( transition.second );
}
}
@@ -308,7 +308,7 @@ bool ExtendedNFA < SymbolType, StateType >::addTransition ( StateType from, rege
if ( !getStates ( ).count ( to ) )
throw AutomatonException ( "State \"" + ext::to_string ( to ) + "\" doesn't exist." );
- std::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > > key = std::make_pair ( std::move ( from ), std::move ( input ) );
+ ext::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > > key = ext::make_pair ( std::move ( from ), std::move ( input ) );
return transitions[std::move ( key )].insert ( std::move ( to ) ).second;
}
@@ -327,47 +327,47 @@ void ExtendedNFA < SymbolType, StateType >::addTransitions ( StateType from, reg
if ( !std::includes ( getStates ( ).begin ( ), getStates ( ).end ( ), to.begin ( ), to.end ( ) ) )
throw AutomatonException ( "Some target states don't exist." );
- std::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > > key = std::make_pair ( std::move ( from ), std::move ( input ) );
+ ext::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > > key = ext::make_pair ( std::move ( from ), std::move ( input ) );
transitions [ std::move ( key ) ].insert ( ext::make_moveable_set ( to ).begin ( ), ext::make_moveable_set ( to ).end ( ) );
}
template<class SymbolType, class StateType >
bool ExtendedNFA < SymbolType, StateType >::removeTransition ( const StateType & from, const regexp::UnboundedRegExpStructure < SymbolType > & input, const StateType & to ) {
- std::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > > key = std::make_pair ( from, input );
+ ext::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > > key = ext::make_pair ( from, input );
return transitions[key].erase ( to );
}
template<class SymbolType, class StateType >
-const ext::map < std::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > >, ext::set < StateType > > & ExtendedNFA < SymbolType, StateType >::getTransitions ( ) const {
+const ext::map < ext::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > >, ext::set < StateType > > & ExtendedNFA < SymbolType, StateType >::getTransitions ( ) const {
return transitions;
}
template<class SymbolType, class StateType >
-ext::map < std::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > >, ext::set < StateType > > ExtendedNFA < SymbolType, StateType >::getTransitionsFromState ( const StateType & from ) const {
+ext::map < ext::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > >, ext::set < StateType > > ExtendedNFA < SymbolType, StateType >::getTransitionsFromState ( const StateType & from ) const {
if ( !getStates ( ).count ( from ) )
throw AutomatonException ( "State \"" + ext::to_string ( from ) + "\" doesn't exist" );
- ext::map < std::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > >, ext::set < StateType > > transitionsFromState;
+ ext::map < ext::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > >, ext::set < StateType > > transitionsFromState;
- for ( const std::pair < const std::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > >, ext::set < StateType > > & transition : transitions )
+ for ( const std::pair < const ext::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > >, ext::set < StateType > > & transition : transitions )
if ( transition.first.first == from )
- transitionsFromState.insert ( make_pair ( transition.first, transition.second ) );
+ transitionsFromState.insert ( std::make_pair ( transition.first, transition.second ) );
return transitionsFromState;
}
template<class SymbolType, class StateType >
-ext::map < std::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > >, ext::set < StateType > > ExtendedNFA < SymbolType, StateType >::getTransitionsToState ( const StateType & to ) const {
+ext::map < ext::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > >, ext::set < StateType > > ExtendedNFA < SymbolType, StateType >::getTransitionsToState ( const StateType & to ) const {
if ( !getStates ( ).count ( to ) )
throw AutomatonException ( "State \"" + ext::to_string ( to ) + "\" doesn't exist" );
- ext::map < std::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > >, ext::set < StateType > > transitionsToState;
+ ext::map < ext::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > >, ext::set < StateType > > transitionsToState;
- for ( const std::pair < const std::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > >, ext::set < StateType > > & transition : transitions )
+ for ( const std::pair < const ext::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > >, ext::set < StateType > > & transition : transitions )
if ( transition.second.find ( to ) != transition.second.end ( ) )
- transitionsToState.insert ( make_pair ( transition.first, transition.second ) );
+ transitionsToState.insert ( std::make_pair ( transition.first, transition.second ) );
return transitionsToState;
}
@@ -476,7 +476,7 @@ template<class SymbolType, class StateType >
class ComponentConstraint< automaton::ExtendedNFA < SymbolType, StateType >, SymbolType, automaton::InputAlphabet > {
public:
static bool used ( const automaton::ExtendedNFA < SymbolType, StateType > & automaton, const SymbolType & symbol ) {
- for ( const std::pair < const std::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > >, ext::set < StateType > > & transition : automaton.getTransitions ( ) ) {
+ for ( const std::pair < const ext::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > >, ext::set < StateType > > & transition : automaton.getTransitions ( ) ) {
ext::set < SymbolType > alphabet = transition.first.second.getStructure ( ).computeMinimalAlphabet ( );
if ( alphabet.count ( symbol ) )
return true;
@@ -503,7 +503,7 @@ public:
if ( automaton.getFinalStates ( ).count ( state ) )
return true;
- for ( const std::pair < const std::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > >, ext::set < StateType > > & transition : automaton.getTransitions ( ) )
+ for ( const std::pair < const ext::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > >, ext::set < StateType > > & transition : automaton.getTransitions ( ) )
if ( ( transition.first.first == state ) || ( transition.second.find ( state ) != transition.second.end ( ) ) )
return true;
diff --git a/alib2data/src/automaton/FSM/MultiInitialStateNFA.h b/alib2data/src/automaton/FSM/MultiInitialStateNFA.h
index d8a39d3c6ec1cfe62fc78a5849f219ec6123fcb1..93ee6d78908f52125d47ce14278bc6e4b5cdcc80 100644
--- a/alib2data/src/automaton/FSM/MultiInitialStateNFA.h
+++ b/alib2data/src/automaton/FSM/MultiInitialStateNFA.h
@@ -38,7 +38,7 @@ class InitialStates;
template < class SymbolType, class StateType >
class MultiInitialStateNFA final : public AutomatonBase, public alib::Components < MultiInitialStateNFA < SymbolType, StateType >, SymbolType, ext::tuple < InputAlphabet >, ext::tuple < >, StateType, ext::tuple < States, InitialStates, FinalStates >, ext::tuple < > > {
protected:
- ext::map < std::pair < StateType, SymbolType >, ext::set < StateType > > transitions;
+ ext::map < ext::pair < StateType, SymbolType >, ext::set < StateType > > transitions;
public:
explicit MultiInitialStateNFA ( );
@@ -142,17 +142,17 @@ public:
/**
* @return automaton transitions
*/
- const ext::map < std::pair < StateType, SymbolType >, ext::set < StateType > > & getTransitions ( ) const;
+ const ext::map < ext::pair < StateType, SymbolType >, ext::set < StateType > > & getTransitions ( ) const;
/**
* @return automaton transitions from state
*/
- ext::map < std::pair < StateType, SymbolType >, ext::set < StateType > > getTransitionsFromState ( const StateType & from ) const;
+ ext::map < ext::pair < StateType, SymbolType >, ext::set < StateType > > getTransitionsFromState ( const StateType & from ) const;
/**
* @return automaton transitions to state
*/
- ext::map < std::pair < StateType, SymbolType >, ext::set < StateType > > getTransitionsToState ( const StateType & from ) const;
+ ext::map < ext::pair < StateType, SymbolType >, ext::set < StateType > > getTransitionsToState ( const StateType & from ) const;
/**
* Determines whether MultiInitialStateNFA is deterministic.
@@ -214,7 +214,7 @@ public:
MultiInitialStateNFA < > * res = new MultiInitialStateNFA < > ( std::move ( states ), std::move ( alphabet ), std::move ( initialStates ), std::move ( finalStates ) );
- for ( std::pair < std::pair < StateType, SymbolType >, ext::set < StateType > > && transition : ext::make_moveable_map ( transitions ) ) {
+ for ( std::pair < ext::pair < StateType, SymbolType >, ext::set < StateType > > && transition : ext::make_moveable_map ( transitions ) ) {
DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) );
DefaultSymbolType input = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( transition.first.second ) );
ext::set < DefaultStateType > targets = AutomatonNormalize::normalizeStates ( std::move ( transition.second ) );
@@ -274,7 +274,7 @@ bool MultiInitialStateNFA < SymbolType, StateType >::addTransition ( StateType f
if ( !getStates ( ).count ( to ) )
throw AutomatonException ( "State \"" + ext::to_string ( to ) + "\" doesn't exist." );
- std::pair < StateType, SymbolType > key = std::make_pair ( std::move ( from ), std::move ( input ) );
+ ext::pair < StateType, SymbolType > key = ext::make_pair ( std::move ( from ), std::move ( input ) );
return transitions[std::move ( key )].insert ( std::move ( to ) ).second;
}
@@ -290,31 +290,31 @@ void MultiInitialStateNFA < SymbolType, StateType >::addTransitions ( StateType
if ( !std::includes ( getStates ( ).begin ( ), getStates ( ).end ( ), to.begin ( ), to.end ( ) ) )
throw AutomatonException ( "Some target states don't exist." );
- std::pair < StateType, SymbolType > key = std::make_pair ( std::move ( from ), std::move ( input ) );
+ ext::pair < StateType, SymbolType > key = ext::make_pair ( std::move ( from ), std::move ( input ) );
transitions [ std::move ( key ) ].insert ( ext::make_moveable_set ( to ).begin ( ), ext::make_moveable_set ( to ).end ( ) );
}
template < class SymbolType, class StateType >
bool MultiInitialStateNFA < SymbolType, StateType >::removeTransition ( const StateType & from, const SymbolType & input, const StateType & to ) {
- std::pair < StateType, SymbolType > key = std::make_pair ( from, input );
+ ext::pair < StateType, SymbolType > key = ext::make_pair ( from, input );
return transitions[key].erase ( to );
}
template < class SymbolType, class StateType >
-const ext::map < std::pair < StateType, SymbolType >, ext::set < StateType > > & MultiInitialStateNFA < SymbolType, StateType >::getTransitions ( ) const {
+const ext::map < ext::pair < StateType, SymbolType >, ext::set < StateType > > & MultiInitialStateNFA < SymbolType, StateType >::getTransitions ( ) const {
return transitions;
}
template < class SymbolType, class StateType >
-ext::map < std::pair < StateType, SymbolType >, ext::set < StateType > > MultiInitialStateNFA < SymbolType, StateType >::getTransitionsFromState ( const StateType & from ) const {
+ext::map < ext::pair < StateType, SymbolType >, ext::set < StateType > > MultiInitialStateNFA < SymbolType, StateType >::getTransitionsFromState ( const StateType & from ) const {
if ( !getStates ( ).count ( from ) )
throw AutomatonException ( "State \"" + ext::to_string ( from ) + "\" doesn't exist" );
- ext::map < std::pair < StateType, SymbolType >, ext::set < StateType > > transitionsFromState;
+ ext::map < ext::pair < StateType, SymbolType >, ext::set < StateType > > transitionsFromState;
- for ( const std::pair < const std::pair < StateType, SymbolType >, ext::set < StateType > > & transition : transitions )
+ for ( const std::pair < const ext::pair < StateType, SymbolType >, ext::set < StateType > > & transition : transitions )
if ( transition.first.first == from )
transitionsFromState[transition.first].insert ( transition.second.begin ( ), transition.second.end ( ) );
@@ -322,13 +322,13 @@ ext::map < std::pair < StateType, SymbolType >, ext::set < StateType > > MultiIn
}
template < class SymbolType, class StateType >
-ext::map < std::pair < StateType, SymbolType >, ext::set < StateType > > MultiInitialStateNFA < SymbolType, StateType >::getTransitionsToState ( const StateType & to ) const {
+ext::map < ext::pair < StateType, SymbolType >, ext::set < StateType > > MultiInitialStateNFA < SymbolType, StateType >::getTransitionsToState ( const StateType & to ) const {
if ( !getStates ( ).count ( to ) )
throw AutomatonException ( "State \"" + ext::to_string ( to ) + "\" doesn't exist" );
- ext::map < std::pair < StateType, SymbolType >, ext::set < StateType > > transitionsToState;
+ ext::map < ext::pair < StateType, SymbolType >, ext::set < StateType > > transitionsToState;
- for ( const std::pair < const std::pair < StateType, SymbolType >, ext::set < StateType > > & transition : transitions )
+ for ( const std::pair < const ext::pair < StateType, SymbolType >, ext::set < StateType > > & transition : transitions )
if ( transition.second.find ( to ) != transition.second.end ( ) )
transitionsToState[transition.first].insert ( transition.second.begin ( ), transition.second.end ( ) );
@@ -337,7 +337,7 @@ ext::map < std::pair < StateType, SymbolType >, ext::set < StateType > > MultiIn
template < class SymbolType, class StateType >
bool MultiInitialStateNFA < SymbolType, StateType >::isDeterministic ( ) const {
- for ( const std::pair < const std::pair < StateType, SymbolType >, ext::set < StateType > > & transition : transitions )
+ for ( const std::pair < const ext::pair < StateType, SymbolType >, ext::set < StateType > > & transition : transitions )
if ( transition.second.size ( ) > 1 )
return false;
@@ -464,7 +464,7 @@ template < class SymbolType, class StateType >
class ComponentConstraint< automaton::MultiInitialStateNFA < SymbolType, StateType >, SymbolType, automaton::InputAlphabet > {
public:
static bool used ( const automaton::MultiInitialStateNFA < SymbolType, StateType > & automaton, const SymbolType & symbol ) {
- for ( const std::pair < const std::pair < StateType, SymbolType >, ext::set < StateType > > & transition : automaton.getTransitions ( ) )
+ for ( const std::pair < const ext::pair < StateType, SymbolType >, ext::set < StateType > > & transition : automaton.getTransitions ( ) )
if ( transition.first.second == symbol )
return true;
@@ -489,7 +489,7 @@ public:
if ( automaton.getFinalStates ( ).count ( state ) )
return true;
- for ( const std::pair < const std::pair < StateType, SymbolType >, ext::set < StateType > > & transition : automaton.getTransitions ( ) )
+ for ( const std::pair < const ext::pair < StateType, SymbolType >, ext::set < StateType > > & transition : automaton.getTransitions ( ) )
if ( ( transition.first.first == state ) || ( transition.second.find ( state ) != transition.second.end ( ) ) )
return true;
diff --git a/alib2data/src/automaton/FSM/NFA.h b/alib2data/src/automaton/FSM/NFA.h
index cdcc398ecb658e25dec0bdee61da389f641405f2..7acac6898591b0fe54ec30c21352682aa1026dc4 100644
--- a/alib2data/src/automaton/FSM/NFA.h
+++ b/alib2data/src/automaton/FSM/NFA.h
@@ -36,7 +36,7 @@ class InitialState;
template<class SymbolType, class StateType >
class NFA final : public AutomatonBase, public alib::Components < NFA < SymbolType, StateType >, SymbolType, ext::tuple < InputAlphabet >, ext::tuple < >, StateType, ext::tuple < States, FinalStates >, ext::tuple < InitialState > > {
protected:
- ext::map < std::pair < StateType, SymbolType >, ext::set < StateType > > transitions;
+ ext::map < ext::pair < StateType, SymbolType >, ext::set < StateType > > transitions;
public:
explicit NFA ( StateType initialState );
@@ -135,17 +135,17 @@ public:
/**
* @return automaton transitions
*/
- const ext::map < std::pair < StateType, SymbolType >, ext::set < StateType > > & getTransitions ( ) const;
+ const ext::map < ext::pair < StateType, SymbolType >, ext::set < StateType > > & getTransitions ( ) const;
/**
* @return automaton transitions from state
*/
- ext::map < std::pair < StateType, SymbolType >, ext::set < StateType > > getTransitionsFromState ( const StateType & from ) const;
+ ext::map < ext::pair < StateType, SymbolType >, ext::set < StateType > > getTransitionsFromState ( const StateType & from ) const;
/**
* @return automaton transitions to state
*/
- ext::map < std::pair < StateType, SymbolType >, ext::set < StateType > > getTransitionsToState ( const StateType & from ) const;
+ ext::map < ext::pair < StateType, SymbolType >, ext::set < StateType > > getTransitionsToState ( const StateType & from ) const;
/**
* Determines whether NFA is deterministic.
@@ -206,7 +206,7 @@ public:
NFA < > * res = new NFA < > ( std::move ( states ), std::move ( alphabet ), std::move ( initialState ), std::move ( finalStates ) );
- for ( std::pair < std::pair < StateType, SymbolType >, ext::set < StateType > > && transition : ext::make_moveable_map ( transitions ) ) {
+ for ( std::pair < ext::pair < StateType, SymbolType >, ext::set < StateType > > && transition : ext::make_moveable_map ( transitions ) ) {
DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) );
DefaultSymbolType input = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( transition.first.second ) );
ext::set < DefaultStateType > targets = AutomatonNormalize::normalizeStates ( std::move ( transition.second ) );
@@ -259,7 +259,7 @@ bool NFA < SymbolType, StateType >::addTransition ( StateType from, SymbolType i
if ( !getStates ( ).count ( to ) )
throw AutomatonException ( "State \"" + ext::to_string ( to ) + "\" doesn't exist." );
- std::pair < StateType, SymbolType > key = std::make_pair ( std::move ( from ), std::move ( input ) );
+ ext::pair < StateType, SymbolType > key = ext::make_pair ( std::move ( from ), std::move ( input ) );
return transitions[std::move ( key )].insert ( std::move ( to ) ).second;
}
@@ -275,31 +275,31 @@ void NFA < SymbolType, StateType >::addTransitions ( StateType from, SymbolType
if ( !std::includes ( getStates ( ).begin ( ), getStates ( ).end ( ), to.begin ( ), to.end ( ) ) )
throw AutomatonException ( "Some target states don't exist." );
- std::pair < StateType, SymbolType > key = std::make_pair ( std::move ( from ), std::move ( input ) );
+ ext::pair < StateType, SymbolType > key = ext::make_pair ( std::move ( from ), std::move ( input ) );
transitions [ std::move ( key ) ].insert ( ext::make_moveable_set ( to ).begin ( ), ext::make_moveable_set ( to ).end ( ) );
}
template<class SymbolType, class StateType >
bool NFA < SymbolType, StateType >::removeTransition ( const StateType & from, const SymbolType & input, const StateType & to ) {
- std::pair < StateType, SymbolType > key = std::make_pair ( from, input );
+ ext::pair < StateType, SymbolType > key = ext::make_pair ( from, input );
return transitions[key].erase ( to );
}
template<class SymbolType, class StateType >
-const ext::map < std::pair < StateType, SymbolType >, ext::set < StateType > > & NFA < SymbolType, StateType >::getTransitions ( ) const {
+const ext::map < ext::pair < StateType, SymbolType >, ext::set < StateType > > & NFA < SymbolType, StateType >::getTransitions ( ) const {
return transitions;
}
template<class SymbolType, class StateType >
-ext::map < std::pair < StateType, SymbolType >, ext::set < StateType > > NFA < SymbolType, StateType >::getTransitionsFromState ( const StateType & from ) const {
+ext::map < ext::pair < StateType, SymbolType >, ext::set < StateType > > NFA < SymbolType, StateType >::getTransitionsFromState ( const StateType & from ) const {
if ( !getStates ( ).count ( from ) )
throw AutomatonException ( "State \"" + ext::to_string ( from ) + "\" doesn't exist" );
- ext::map < std::pair < StateType, SymbolType >, ext::set < StateType > > transitionsFromState;
+ ext::map < ext::pair < StateType, SymbolType >, ext::set < StateType > > transitionsFromState;
- for ( const std::pair < const std::pair < StateType, SymbolType >, ext::set < StateType > > & transition : transitions )
+ for ( const std::pair < const ext::pair < StateType, SymbolType >, ext::set < StateType > > & transition : transitions )
if ( transition.first.first == from )
transitionsFromState[transition.first].insert ( transition.second.begin ( ), transition.second.end ( ) );
@@ -307,13 +307,13 @@ ext::map < std::pair < StateType, SymbolType >, ext::set < StateType > > NFA < S
}
template<class SymbolType, class StateType >
-ext::map < std::pair < StateType, SymbolType >, ext::set < StateType > > NFA < SymbolType, StateType >::getTransitionsToState ( const StateType & to ) const {
+ext::map < ext::pair < StateType, SymbolType >, ext::set < StateType > > NFA < SymbolType, StateType >::getTransitionsToState ( const StateType & to ) const {
if ( !getStates ( ).count ( to ) )
throw AutomatonException ( "State \"" + ext::to_string ( to ) + "\" doesn't exist" );
- ext::map < std::pair < StateType, SymbolType >, ext::set < StateType > > transitionsToState;
+ ext::map < ext::pair < StateType, SymbolType >, ext::set < StateType > > transitionsToState;
- for ( const std::pair < const std::pair < StateType, SymbolType >, ext::set < StateType > > & transition : transitions )
+ for ( const std::pair < const ext::pair < StateType, SymbolType >, ext::set < StateType > > & transition : transitions )
if ( transition.second.find ( to ) != transition.second.end ( ) )
transitionsToState[transition.first].insert ( transition.second.begin ( ), transition.second.end ( ) );
@@ -322,7 +322,7 @@ ext::map < std::pair < StateType, SymbolType >, ext::set < StateType > > NFA < S
template<class SymbolType, class StateType >
bool NFA < SymbolType, StateType >::isDeterministic ( ) const {
- for ( const std::pair < const std::pair < StateType, SymbolType >, ext::set < StateType > > & transition : transitions )
+ for ( const std::pair < const ext::pair < StateType, SymbolType >, ext::set < StateType > > & transition : transitions )
if ( transition.second.size ( ) > 1 )
return false;
@@ -448,7 +448,7 @@ template<class SymbolType, class StateType >
class ComponentConstraint< automaton::NFA < SymbolType, StateType >, SymbolType, automaton::InputAlphabet > {
public:
static bool used ( const automaton::NFA < SymbolType, StateType > & automaton, const SymbolType & symbol ) {
- for ( const std::pair < const std::pair < StateType, SymbolType >, ext::set < StateType > > & transition : automaton.getTransitions ( ) )
+ for ( const std::pair < const ext::pair < StateType, SymbolType >, ext::set < StateType > > & transition : automaton.getTransitions ( ) )
if ( transition.first.second == symbol )
return true;
@@ -473,7 +473,7 @@ public:
if ( automaton.getFinalStates ( ).count ( state ) )
return true;
- for ( const std::pair < const std::pair < StateType, SymbolType >, ext::set < StateType > > & transition : automaton.getTransitions ( ) )
+ for ( const std::pair < const ext::pair < StateType, SymbolType >, ext::set < StateType > > & transition : automaton.getTransitions ( ) )
if ( ( transition.first.first == state ) || ( transition.second.find ( state ) != transition.second.end ( ) ) )
return true;
diff --git a/alib2data/src/automaton/PDA/DPDA.h b/alib2data/src/automaton/PDA/DPDA.h
index 991d04eb72968f05373b304e63c1dc62c6eac9b5..a487f4ca4e61d295de88a9289e34698842b20456 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, ext::tuple < InputAlphabet>, ext::tuple < >, PushdownStoreSymbolType, ext::tuple < PushdownStoreAlphabet >, ext::tuple < InitialSymbol >, StateType, ext::tuple < States, FinalStates >, ext::tuple < InitialState > > {
protected:
- ext::map < ext::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector < PushdownStoreSymbolType > >, std::pair < StateType, ext::vector < PushdownStoreSymbolType > > > transitions;
+ ext::map < ext::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector < PushdownStoreSymbolType > >, ext::pair < StateType, ext::vector < PushdownStoreSymbolType > > > transitions;
public:
explicit DPDA ( ext::set < StateType > states, ext::set < InputSymbolType > inputAlphabet, ext::set < PushdownStoreSymbolType > pushdownStoreSymbol, StateType initialState, PushdownStoreSymbolType initialPushdownSymbol, ext::set < StateType > finalStates );
@@ -170,17 +170,17 @@ public:
/**
* @return DPDA transitions
*/
- const ext::map < ext::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector < PushdownStoreSymbolType > >, std::pair < StateType, ext::vector < PushdownStoreSymbolType > > > & getTransitions ( ) const;
+ const ext::map < ext::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector < PushdownStoreSymbolType > >, ext::pair < StateType, ext::vector < PushdownStoreSymbolType > > > & getTransitions ( ) const;
/**
* @return automaton transitions from state
*/
- ext::map < ext::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector < PushdownStoreSymbolType > >, std::pair < StateType, ext::vector < PushdownStoreSymbolType > > > getTransitionsFromState ( const StateType & from ) const;
+ ext::map < ext::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector < PushdownStoreSymbolType > >, ext::pair < StateType, ext::vector < PushdownStoreSymbolType > > > getTransitionsFromState ( const StateType & from ) const;
/**
* @return automaton transitions to state
*/
- ext::map < ext::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector < PushdownStoreSymbolType > >, std::pair < StateType, ext::vector < PushdownStoreSymbolType > > > getTransitionsToState ( const StateType & from ) const;
+ ext::map < ext::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector < PushdownStoreSymbolType > >, ext::pair < StateType, ext::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,7 +223,7 @@ 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 < ext::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector < PushdownStoreSymbolType > >, std::pair < StateType, ext::vector < PushdownStoreSymbolType > > > && transition : ext::make_moveable_map ( transitions ) ) {
+ for ( std::pair < ext::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector < PushdownStoreSymbolType > >, ext::pair < StateType, ext::vector < PushdownStoreSymbolType > > > && transition : ext::make_moveable_map ( transitions ) ) {
ext::vector < DefaultSymbolType > pop = alphabet::SymbolNormalize::normalizeSymbols ( std::move ( std::get < 2 > ( transition.first ) ) );
DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( std::get < 0 > ( transition.first ) ) );
ext::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( std::get < 1 > ( transition.first ) ) );
@@ -283,7 +283,7 @@ bool DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::
}
ext::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, ext::vector<PushdownStoreSymbolType> > key(std::move(from), std::move(input), std::move(pop));
- std::pair<StateType, ext::vector<PushdownStoreSymbolType> > value = std::make_pair(std::move(to), std::move(push));
+ ext::pair<StateType, ext::vector<PushdownStoreSymbolType> > value = ext::make_pair(std::move(to), std::move(push));
if (transitions.find(key) != transitions.end()) {
if(transitions.find(key)->second == value)
@@ -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 ext::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, ext::vector<PushdownStoreSymbolType> >, std::pair<StateType, ext::vector<PushdownStoreSymbolType> > > & transition) {
+ if(std::any_of(transitions.begin(), transitions.end(), [&](const std::pair<const ext::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, ext::vector<PushdownStoreSymbolType> >, ext::pair<StateType, ext::vector<PushdownStoreSymbolType> > > & transition) {
if(std::get<0>(transition.first) == std::get<0>(key)) {
const ext::vector<PushdownStoreSymbolType>& alpha = std::get<2>(transition.first);
const ext::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 ext::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, ext::vector<PushdownStoreSymbolType> >, std::pair<StateType, ext::vector<PushdownStoreSymbolType> > > & transition) {
+ if(std::any_of(transitions.begin(), transitions.end(), [&](const std::pair<const ext::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, ext::vector<PushdownStoreSymbolType> >, ext::pair<StateType, ext::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 ext::vector<PushdownStoreSymbolType>& alpha = std::get<2>(transition.first);
const ext::vector<PushdownStoreSymbolType>& beta = std::get<2>(key);
@@ -351,7 +351,7 @@ 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 ext::variant<EpsilonType, InputSymbolType>& input, const ext::vector < PushdownStoreSymbolType > & pop, const StateType& to, const ext::vector < PushdownStoreSymbolType > & push) {
ext::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, ext::vector < PushdownStoreSymbolType > > key(from, input, pop);
- std::pair<StateType, ext::vector < PushdownStoreSymbolType > > value = std::make_pair(to, push);
+ ext::pair<StateType, ext::vector < PushdownStoreSymbolType > > value = ext::make_pair(to, push);
if (transitions.find(key) == transitions.end())
return false;
@@ -382,17 +382,17 @@ bool DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-const ext::map<ext::tuple<StateType, ext::variant<EpsilonType, InputSymbolType >, ext::vector<PushdownStoreSymbolType> >, std::pair<StateType, ext::vector<PushdownStoreSymbolType> > >& DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getTransitions() const {
+const ext::map<ext::tuple<StateType, ext::variant<EpsilonType, InputSymbolType >, ext::vector<PushdownStoreSymbolType> >, ext::pair<StateType, ext::vector<PushdownStoreSymbolType> > >& DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getTransitions() const {
return transitions;
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-ext::map<ext::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, ext::vector<PushdownStoreSymbolType> >, std::pair<StateType, ext::vector<PushdownStoreSymbolType> > > DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getTransitionsFromState(const StateType& from) const {
+ext::map<ext::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, ext::vector<PushdownStoreSymbolType> >, ext::pair<StateType, ext::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");
- ext::map<ext::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, ext::vector<PushdownStoreSymbolType> >, std::pair<StateType, ext::vector<PushdownStoreSymbolType> > > transitionsFromState;
- for (const std::pair<const ext::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, ext::vector<PushdownStoreSymbolType> >, std::pair<StateType, ext::vector<PushdownStoreSymbolType> > >& transition : transitions) {
+ ext::map<ext::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, ext::vector<PushdownStoreSymbolType> >, ext::pair<StateType, ext::vector<PushdownStoreSymbolType> > > transitionsFromState;
+ for ( const std::pair<const ext::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, ext::vector<PushdownStoreSymbolType> >, ext::pair<StateType, ext::vector<PushdownStoreSymbolType> > >& transition : transitions) {
if (std::get<0>(transition.first) == from) {
transitionsFromState.insert(std::make_pair(transition.first, transition.second));
}
@@ -402,12 +402,12 @@ ext::map<ext::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, ext::
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-ext::map<ext::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, ext::vector<PushdownStoreSymbolType> >, std::pair<StateType, ext::vector<PushdownStoreSymbolType> > > DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getTransitionsToState(const StateType& to) const {
+ext::map<ext::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, ext::vector<PushdownStoreSymbolType> >, ext::pair<StateType, ext::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");
- ext::map<ext::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, ext::vector<PushdownStoreSymbolType> >, std::pair<StateType, ext::vector<PushdownStoreSymbolType> > > transitionsToState;
- for (const std::pair<const ext::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, ext::vector<PushdownStoreSymbolType> >, std::pair<StateType, ext::vector<PushdownStoreSymbolType> > >& transition : transitions) {
+ ext::map<ext::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, ext::vector<PushdownStoreSymbolType> >, ext::pair<StateType, ext::vector<PushdownStoreSymbolType> > > transitionsToState;
+ for ( const std::pair<const ext::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, ext::vector<PushdownStoreSymbolType> >, ext::pair<StateType, ext::vector<PushdownStoreSymbolType> > >& transition : transitions) {
if (transition.second.first == to) {
transitionsToState.insert(std::make_pair(transition.first, transition.second));
}
@@ -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 ext::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, ext::vector<PushdownStoreSymbolType> >, std::pair<StateType, ext::vector<PushdownStoreSymbolType> > >& transition : automaton.getTransitions())
+ for ( const std::pair<const ext::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, ext::vector<PushdownStoreSymbolType> >, ext::pair<StateType, ext::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 ext::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, ext::vector<PushdownStoreSymbolType> >, std::pair<StateType, ext::vector<PushdownStoreSymbolType> > >& transition : automaton.getTransitions()) {
+ for ( const std::pair<const ext::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, ext::vector<PushdownStoreSymbolType> >, ext::pair<StateType, ext::vector<PushdownStoreSymbolType> > >& transition : automaton.getTransitions()) {
const auto & popSymbols = std::get<2>(transition.first);
const auto & pushSymbols = transition.second.second;
if(ext::contains(popSymbols.begin(), popSymbols.end(), symbol ) || ext::contains(pushSymbols.begin(), pushSymbols.end(), symbol))
@@ -588,7 +588,7 @@ public:
if ( automaton.getFinalStates ( ).count ( state ) )
return true;
- for (const std::pair<const ext::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, ext::vector<PushdownStoreSymbolType> >, std::pair<StateType, ext::vector<PushdownStoreSymbolType> > >& transition : automaton.getTransitions())
+ for ( const std::pair<const ext::tuple<StateType, ext::variant<EpsilonType, InputSymbolType>, ext::vector<PushdownStoreSymbolType> >, ext::pair<StateType, ext::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/InputDrivenDPDA.h b/alib2data/src/automaton/PDA/InputDrivenDPDA.h
index aa6823cf9d9b97af5b3cd094ae91207836385c41..67973530aee582077eaa533f03ac4249e6912258 100644
--- a/alib2data/src/automaton/PDA/InputDrivenDPDA.h
+++ b/alib2data/src/automaton/PDA/InputDrivenDPDA.h
@@ -42,8 +42,8 @@ class InitialState;
template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
class InputDrivenDPDA final : public AutomatonBase, public alib::Components < InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >, InputSymbolType, ext::tuple < InputAlphabet >, ext::tuple < >, PushdownStoreSymbolType, ext::tuple < PushdownStoreAlphabet >, ext::tuple < InitialSymbol >, StateType, ext::tuple < States, FinalStates >, ext::tuple < InitialState > > {
protected:
- ext::map < std::pair < StateType, InputSymbolType >, StateType > transitions;
- ext::map < InputSymbolType, std::pair < ext::vector < PushdownStoreSymbolType >, ext::vector < PushdownStoreSymbolType > > > inputSymbolToPushdownStoreOperation;
+ ext::map < ext::pair < StateType, InputSymbolType >, StateType > transitions;
+ ext::map < InputSymbolType, ext::pair < ext::vector < PushdownStoreSymbolType >, ext::vector < PushdownStoreSymbolType > > > inputSymbolToPushdownStoreOperation;
void checkPushdownStoreOperation ( const InputSymbolType & input, const ext::vector < PushdownStoreSymbolType > & pop, const ext::vector < PushdownStoreSymbolType > & push );
@@ -145,11 +145,11 @@ public:
bool setPushdownStoreOperation ( InputSymbolType input, ext::vector < PushdownStoreSymbolType > pop, ext::vector < PushdownStoreSymbolType > push );
- void setPushdownStoreOperations ( ext::map < InputSymbolType, std::pair < ext::vector < PushdownStoreSymbolType >, ext::vector < PushdownStoreSymbolType > > > operations );
+ void setPushdownStoreOperations ( ext::map < InputSymbolType, ext::pair < ext::vector < PushdownStoreSymbolType >, ext::vector < PushdownStoreSymbolType > > > operations );
bool clearPushdownStoreOperation ( const InputSymbolType & input );
- const ext::map < InputSymbolType, std::pair < ext::vector < PushdownStoreSymbolType >, ext::vector < PushdownStoreSymbolType > > > & getPushdownStoreOperations ( ) const;
+ const ext::map < InputSymbolType, ext::pair < ext::vector < PushdownStoreSymbolType >, ext::vector < PushdownStoreSymbolType > > > & getPushdownStoreOperations ( ) const;
/**
* Adds transition defined by parameters to the automaton.
@@ -170,11 +170,11 @@ public:
/**
* @return automaton transitions
*/
- const ext::map < std::pair < StateType, InputSymbolType >, StateType > & getTransitions ( ) const;
+ const ext::map < ext::pair < StateType, InputSymbolType >, StateType > & getTransitions ( ) const;
- ext::map < std::pair < StateType, InputSymbolType >, StateType > getTransitionsFromState ( const StateType & from ) const;
+ ext::map < ext::pair < StateType, InputSymbolType >, StateType > getTransitionsFromState ( const StateType & from ) const;
- ext::map < std::pair < StateType, InputSymbolType >, StateType > getTransitionsToState ( const StateType & to ) const;
+ ext::map < ext::pair < StateType, InputSymbolType >, StateType > getTransitionsToState ( const StateType & to ) const;
/**
* Determines whether InputDrivenDPDA is deterministic.
@@ -227,7 +227,7 @@ public:
InputDrivenDPDA < > * res = new InputDrivenDPDA < > ( std::move ( states ), std::move ( alphabet ), std::move ( pushdownAlphabet ), std::move ( initialState ), std::move ( initialSymbol ), std::move ( finalStates ) );
- for ( std::pair < InputSymbolType, std::pair < ext::vector < InputSymbolType >, ext::vector < InputSymbolType > > > && pushdownOperation : ext::make_moveable_map ( inputSymbolToPushdownStoreOperation ) ) {
+ for ( std::pair < InputSymbolType, ext::pair < ext::vector < InputSymbolType >, ext::vector < InputSymbolType > > > && pushdownOperation : ext::make_moveable_map ( inputSymbolToPushdownStoreOperation ) ) {
DefaultSymbolType target = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( pushdownOperation.first ) );
ext::vector < DefaultSymbolType > pop = alphabet::SymbolNormalize::normalizeSymbols ( std::move ( pushdownOperation.second.first ) );
ext::vector < DefaultSymbolType > push = alphabet::SymbolNormalize::normalizeSymbols ( std::move ( pushdownOperation.second.second ) );
@@ -235,7 +235,7 @@ public:
res->setPushdownStoreOperation ( std::move ( target ), std::move ( pop ), std::move ( push ) );
}
- for ( std::pair < std::pair < StateType, InputSymbolType >, StateType > && transition : ext::make_moveable_map ( transitions ) ) {
+ for ( std::pair < ext::pair < StateType, InputSymbolType >, StateType > && transition : ext::make_moveable_map ( transitions ) ) {
DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) );
DefaultSymbolType input = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( transition.first.second ) );
@@ -288,11 +288,11 @@ void InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::ch
template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
bool InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::setPushdownStoreOperation ( InputSymbolType input, ext::vector<PushdownStoreSymbolType> pop, ext::vector<PushdownStoreSymbolType> push) {
checkPushdownStoreOperation(input, pop, push);
- return inputSymbolToPushdownStoreOperation.insert(std::make_pair(std::move(input), std::make_pair(std::move(pop), std::move(push)))).second;
+ return inputSymbolToPushdownStoreOperation.insert(std::make_pair(std::move(input), ext::make_pair(std::move(pop), std::move(push)))).second;
}
template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
-void InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::setPushdownStoreOperations(ext::map<InputSymbolType, std::pair<ext::vector<PushdownStoreSymbolType>, ext::vector<PushdownStoreSymbolType>>> operations) {
+void InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::setPushdownStoreOperations(ext::map<InputSymbolType, ext::pair<ext::vector<PushdownStoreSymbolType>, ext::vector<PushdownStoreSymbolType>>> operations) {
ext::set<InputSymbolType> removed;
std::set_difference(getInputAlphabet().begin(), getInputAlphabet().end(), ext::key_begin(operations), ext::key_end(operations), std::inserter(removed, removed.end()));
@@ -309,7 +309,7 @@ void InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::se
template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
bool InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::clearPushdownStoreOperation(const InputSymbolType& input) {
- for (const std::pair<const std::pair<StateType, InputSymbolType>, StateType>& transition : transitions) {
+ for ( const std::pair<const ext::pair<StateType, InputSymbolType>, StateType>& transition : transitions) {
if (transition.first.second == input)
throw AutomatonException("Input symbol \"" + ext::to_string ( input ) + "\" is used.");
}
@@ -318,7 +318,7 @@ bool InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::cl
}
template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
-const ext::map < InputSymbolType, std::pair<ext::vector<PushdownStoreSymbolType>, ext::vector<PushdownStoreSymbolType>>>& InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::getPushdownStoreOperations() const {
+const ext::map < InputSymbolType, ext::pair<ext::vector<PushdownStoreSymbolType>, ext::vector<PushdownStoreSymbolType>>>& InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::getPushdownStoreOperations() const {
return inputSymbolToPushdownStoreOperation;
}
@@ -336,7 +336,7 @@ bool InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::ad
if (! getStates().count(to))
throw AutomatonException("State \"" + ext::to_string ( to ) + "\" doesn't exist.");
- std::pair<StateType, InputSymbolType> key = std::make_pair(std::move(from), std::move(input));
+ ext::pair<StateType, InputSymbolType> key = ext::make_pair(std::move(from), std::move(input));
if (transitions.find(key) != transitions.end()) {
if(transitions.find(key)->second == to)
@@ -351,7 +351,7 @@ bool InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::ad
template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
bool InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::removeTransition(const StateType& from, const InputSymbolType& input, const StateType& to) {
- std::pair<StateType, InputSymbolType> key = std::make_pair(from, input);
+ ext::pair<StateType, InputSymbolType> key = ext::make_pair(from, input);
if (transitions.find(key) == transitions.end())
return false;
@@ -364,17 +364,17 @@ bool InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::re
}
template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
-const ext::map<std::pair<StateType, InputSymbolType>, StateType>& InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::getTransitions() const {
+const ext::map<ext::pair<StateType, InputSymbolType>, StateType>& InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::getTransitions() const {
return transitions;
}
template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
-ext::map<std::pair<StateType, InputSymbolType>, StateType > InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::getTransitionsFromState(const StateType& from) const {
+ext::map<ext::pair<StateType, InputSymbolType>, StateType > InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::getTransitionsFromState(const StateType& from) const {
if( ! getStates().count(from))
throw AutomatonException("State \"" + ext::to_string ( from ) + "\" doesn't exist");
- ext::map<std::pair<StateType, InputSymbolType>, StateType> transitionsFromState;
- for (const std::pair<const std::pair<StateType, InputSymbolType>, StateType>& transition : transitions) {
+ ext::map<ext::pair<StateType, InputSymbolType>, StateType> transitionsFromState;
+ for ( const std::pair<const ext::pair<StateType, InputSymbolType>, StateType>& transition : transitions) {
if (transition.first.first == from) {
transitionsFromState.insert(transition);
}
@@ -384,12 +384,12 @@ ext::map<std::pair<StateType, InputSymbolType>, StateType > InputDrivenDPDA < In
}
template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
-ext::map<std::pair<StateType, InputSymbolType>, StateType> InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::getTransitionsToState(const StateType& to) const {
+ext::map<ext::pair<StateType, InputSymbolType>, StateType> InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::getTransitionsToState(const StateType& to) const {
if( ! getStates().count(to))
throw AutomatonException("State \"" + ext::to_string ( to ) + "\" doesn't exist");
- ext::map<std::pair<StateType, InputSymbolType>, StateType> transitionsToState;
- for (const std::pair<const std::pair<StateType, InputSymbolType>, StateType>& transition : transitions) {
+ ext::map<ext::pair<StateType, InputSymbolType>, StateType> transitionsToState;
+ for ( const std::pair<const ext::pair<StateType, InputSymbolType>, StateType>& transition : transitions) {
if (transition.second == to) {
transitionsToState.insert(transition);
}
@@ -508,7 +508,7 @@ template < class InputSymbolType, class PushdownStoreSymbolType, class StateType
class ComponentConstraint< automaton::InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >, InputSymbolType, automaton::InputAlphabet > {
public:
static bool used ( const automaton::InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & automaton, const InputSymbolType & symbol ) {
- for (const std::pair<const std::pair<StateType, InputSymbolType>, StateType>& transition : automaton.getTransitions())
+ for ( const std::pair<const ext::pair<StateType, InputSymbolType>, StateType>& transition : automaton.getTransitions())
if (transition.first.second == symbol)
return true;
@@ -569,7 +569,7 @@ public:
if ( automaton.getFinalStates ( ).count ( state ) )
return true;
- for (const std::pair<const std::pair<StateType, InputSymbolType>, StateType>& t : automaton.getTransitions())
+ for ( const std::pair<const ext::pair<StateType, InputSymbolType>, StateType>& t : automaton.getTransitions())
if (t.first.first == state || t.second == state)
return true;
diff --git a/alib2data/src/automaton/PDA/InputDrivenNPDA.h b/alib2data/src/automaton/PDA/InputDrivenNPDA.h
index 9d4242e7c0f11834f73c8967279aade1a8270106..6eaa97730bf81229180e76f3fc8c207b23be44de 100644
--- a/alib2data/src/automaton/PDA/InputDrivenNPDA.h
+++ b/alib2data/src/automaton/PDA/InputDrivenNPDA.h
@@ -42,8 +42,8 @@ class InitialState;
template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
class InputDrivenNPDA final : public AutomatonBase, public alib::Components < InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >, InputSymbolType, ext::tuple < InputAlphabet >, ext::tuple < >, PushdownStoreSymbolType, ext::tuple < PushdownStoreAlphabet >, ext::tuple < InitialSymbol >, StateType, ext::tuple < States, FinalStates >, ext::tuple < InitialState > > {
protected:
- ext::map < std::pair < StateType, InputSymbolType >, ext::set < StateType > > transitions;
- ext::map < InputSymbolType, std::pair < ext::vector < PushdownStoreSymbolType >, ext::vector < PushdownStoreSymbolType > > > inputSymbolToPushdownStoreOperation;
+ ext::map < ext::pair < StateType, InputSymbolType >, ext::set < StateType > > transitions;
+ ext::map < InputSymbolType, ext::pair < ext::vector < PushdownStoreSymbolType >, ext::vector < PushdownStoreSymbolType > > > inputSymbolToPushdownStoreOperation;
void checkPushdownStoreOperation ( const InputSymbolType & input, const ext::vector < PushdownStoreSymbolType > & pop, const ext::vector < PushdownStoreSymbolType > & push );
@@ -145,11 +145,11 @@ public:
bool setPushdownStoreOperation ( InputSymbolType input, ext::vector < PushdownStoreSymbolType > pop, ext::vector < PushdownStoreSymbolType > push );
- void setPushdownStoreOperations ( ext::map < InputSymbolType, std::pair < ext::vector < PushdownStoreSymbolType >, ext::vector < PushdownStoreSymbolType > > > operations );
+ void setPushdownStoreOperations ( ext::map < InputSymbolType, ext::pair < ext::vector < PushdownStoreSymbolType >, ext::vector < PushdownStoreSymbolType > > > operations );
bool clearPushdownStoreOperation ( const InputSymbolType & input );
- const ext::map < InputSymbolType, std::pair < ext::vector < PushdownStoreSymbolType >, ext::vector < PushdownStoreSymbolType > > > & getPushdownStoreOperations ( ) const;
+ const ext::map < InputSymbolType, ext::pair < ext::vector < PushdownStoreSymbolType >, ext::vector < PushdownStoreSymbolType > > > & getPushdownStoreOperations ( ) const;
/**
* Adds transition defined by parameters to the automaton.
@@ -179,11 +179,11 @@ public:
/**
* @return automaton transitions
*/
- const ext::map < std::pair < StateType, InputSymbolType >, ext::set < StateType > > & getTransitions ( ) const;
+ const ext::map < ext::pair < StateType, InputSymbolType >, ext::set < StateType > > & getTransitions ( ) const;
- ext::map < std::pair < StateType, InputSymbolType >, ext::set < StateType > > getTransitionsFromState ( const StateType & from ) const;
+ ext::map < ext::pair < StateType, InputSymbolType >, ext::set < StateType > > getTransitionsFromState ( const StateType & from ) const;
- ext::map < std::pair < StateType, InputSymbolType >, ext::set < StateType > > getTransitionsToState ( const StateType & to ) const;
+ ext::map < ext::pair < StateType, InputSymbolType >, ext::set < StateType > > getTransitionsToState ( const StateType & to ) const;
/**
* Determines whether InputDrivenNPDA is deterministic.
@@ -236,7 +236,7 @@ public:
InputDrivenNPDA < > * res = new InputDrivenNPDA < > ( std::move ( states ), std::move ( alphabet ), std::move ( pushdownAlphabet ), std::move ( initialState ), std::move ( initialSymbol ), std::move ( finalStates ) );
- for ( std::pair < InputSymbolType, std::pair < ext::vector < InputSymbolType >, ext::vector < InputSymbolType > > > && pushdownOperation : ext::make_moveable_map ( inputSymbolToPushdownStoreOperation ) ) {
+ for ( std::pair < InputSymbolType, ext::pair < ext::vector < InputSymbolType >, ext::vector < InputSymbolType > > > && pushdownOperation : ext::make_moveable_map ( inputSymbolToPushdownStoreOperation ) ) {
DefaultSymbolType target = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( pushdownOperation.first ) );
ext::vector < DefaultSymbolType > pop = alphabet::SymbolNormalize::normalizeSymbols ( std::move ( pushdownOperation.second.first ) );
ext::vector < DefaultSymbolType > push = alphabet::SymbolNormalize::normalizeSymbols ( std::move ( pushdownOperation.second.second ) );
@@ -244,7 +244,7 @@ public:
res->setPushdownStoreOperation ( std::move ( target ), std::move ( pop ), std::move ( push ) );
}
- for ( std::pair < std::pair < StateType, InputSymbolType >, ext::set < StateType > > && transition : ext::make_moveable_map ( transitions ) ) {
+ for ( std::pair < ext::pair < StateType, InputSymbolType >, ext::set < StateType > > && transition : ext::make_moveable_map ( transitions ) ) {
ext::set < DefaultStateType > targets = AutomatonNormalize::normalizeStates ( std::move ( transition.second ) );
DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) );
@@ -297,11 +297,11 @@ void InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::ch
template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
bool InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::setPushdownStoreOperation ( InputSymbolType input, ext::vector<PushdownStoreSymbolType> pop, ext::vector<PushdownStoreSymbolType> push) {
checkPushdownStoreOperation(input, pop, push);
- return inputSymbolToPushdownStoreOperation.insert(std::make_pair(input, std::make_pair(pop, push))).second;
+ return inputSymbolToPushdownStoreOperation.insert(std::make_pair(input, ext::make_pair(pop, push))).second;
}
template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
-void InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::setPushdownStoreOperations(ext::map < InputSymbolType, std::pair<ext::vector<PushdownStoreSymbolType>, ext::vector<PushdownStoreSymbolType>>> operations) {
+void InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::setPushdownStoreOperations(ext::map < InputSymbolType, ext::pair<ext::vector<PushdownStoreSymbolType>, ext::vector<PushdownStoreSymbolType>>> operations) {
ext::set < InputSymbolType> removed;
std::set_difference(getInputAlphabet().begin(), getInputAlphabet().end(), ext::key_begin(operations), ext::key_end(operations), std::inserter(removed, removed.end()));
@@ -318,7 +318,7 @@ void InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::se
template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
bool InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::clearPushdownStoreOperation(const InputSymbolType& input) {
- for (const std::pair<const std::pair<StateType, InputSymbolType>, ext::set<StateType > >& transition : transitions) {
+ for ( const std::pair<const ext::pair<StateType, InputSymbolType>, ext::set<StateType > >& transition : transitions) {
if (transition.first.second == input)
throw AutomatonException("Input symbol \"" + ext::to_string ( input ) + "\" is used.");
}
@@ -327,7 +327,7 @@ bool InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::cl
}
template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
-const ext::map < InputSymbolType, std::pair<ext::vector<PushdownStoreSymbolType>, ext::vector<PushdownStoreSymbolType>>>& InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::getPushdownStoreOperations() const {
+const ext::map < InputSymbolType, ext::pair<ext::vector<PushdownStoreSymbolType>, ext::vector<PushdownStoreSymbolType>>>& InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::getPushdownStoreOperations() const {
return inputSymbolToPushdownStoreOperation;
}
@@ -345,7 +345,7 @@ bool InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::ad
if (! getStates().count(to))
throw AutomatonException("State \"" + ext::to_string ( to ) + "\" doesn't exist.");
- std::pair<StateType, InputSymbolType> key = std::make_pair(std::move(from), std::move(input));
+ ext::pair<StateType, InputSymbolType> key = ext::make_pair(std::move(from), std::move(input));
return transitions[std::move(key)].insert(std::move(to)).second;
}
@@ -364,29 +364,29 @@ void InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::ad
if ( !std::includes ( getStates ( ).begin ( ), getStates ( ).end ( ), to.begin ( ), to.end ( ) ) )
throw AutomatonException ( "Some target states don't exist." );
- std::pair<StateType, InputSymbolType> key = std::make_pair(std::move(from), std::move(input));
+ ext::pair<StateType, InputSymbolType> key = ext::make_pair(std::move(from), std::move(input));
transitions [ std::move ( key ) ].insert ( ext::make_moveable_set ( to ).begin ( ), ext::make_moveable_set ( to ).end ( ) );
}
template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
bool InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::removeTransition(const StateType& from, const InputSymbolType& input, const StateType& to) {
- std::pair<StateType, InputSymbolType> key = std::make_pair(from, input);
+ ext::pair<StateType, InputSymbolType> key = ext::make_pair(from, input);
return transitions[key].erase(to);
}
template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
-const ext::map<std::pair < StateType, InputSymbolType >, ext::set<StateType > >& InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::getTransitions() const {
+const ext::map<ext::pair < StateType, InputSymbolType >, ext::set<StateType > >& InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::getTransitions() const {
return transitions;
}
template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
-ext::map<std::pair<StateType, InputSymbolType>, ext::set<StateType > > InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::getTransitionsFromState(const StateType& from) const {
+ext::map<ext::pair<StateType, InputSymbolType>, ext::set<StateType > > InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::getTransitionsFromState(const StateType& from) const {
if (! getStates().count(from))
throw AutomatonException("State \"" + ext::to_string ( from ) + "\" doesn't exist");
- ext::map<std::pair<StateType, InputSymbolType>, ext::set<StateType > > transitionsFromState;
- for (const std::pair<const std::pair < StateType, InputSymbolType>, ext::set<StateType > >& transition : transitions) {
+ ext::map<ext::pair<StateType, InputSymbolType>, ext::set<StateType > > transitionsFromState;
+ for ( const std::pair<const ext::pair < StateType, InputSymbolType>, ext::set<StateType > >& transition : transitions) {
if (transition.first.first == from) {
transitionsFromState[transition.first].insert(transition.second.begin(), transition.second.end());
}
@@ -396,12 +396,12 @@ ext::map<std::pair<StateType, InputSymbolType>, ext::set<StateType > > InputDriv
}
template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
-ext::map<std::pair<StateType, InputSymbolType>, ext::set<StateType > > InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::getTransitionsToState(const StateType& to) const {
+ext::map<ext::pair<StateType, InputSymbolType>, ext::set<StateType > > InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::getTransitionsToState(const StateType& to) const {
if (! getStates().count(to))
throw AutomatonException("State \"" + ext::to_string ( to ) + "\" doesn't exist");
- ext::map<std::pair<StateType, InputSymbolType>, ext::set<StateType > > transitionsToState;
- for (const std::pair<const std::pair<StateType, InputSymbolType>, ext::set<StateType > >& transition : transitions) {
+ ext::map<ext::pair<StateType, InputSymbolType>, ext::set<StateType > > transitionsToState;
+ for ( const std::pair<const ext::pair<StateType, InputSymbolType>, ext::set<StateType > >& transition : transitions) {
if (transition.second.find(to) != transition.second.end()) {
transitionsToState[transition.first].insert(transition.second.begin(), transition.second.end());
}
@@ -412,7 +412,7 @@ ext::map<std::pair<StateType, InputSymbolType>, ext::set<StateType > > InputDriv
template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
bool InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::isDeterministic() const {
- for (const std::pair<const std::pair<StateType, InputSymbolType>, ext::set<StateType > >& transition : transitions) {
+ for ( const std::pair<const ext::pair<StateType, InputSymbolType>, ext::set<StateType > >& transition : transitions) {
if (transition.second.size() != 1 || transition.second.size() != 0) {
return false;
}
@@ -533,7 +533,7 @@ template < class InputSymbolType, class PushdownStoreSymbolType, class StateType
class ComponentConstraint< automaton::InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >, InputSymbolType, automaton::InputAlphabet > {
public:
static bool used ( const automaton::InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & automaton, const InputSymbolType & symbol ) {
- for (const std::pair<const std::pair<StateType, InputSymbolType>, ext::set<StateType >>& transition : automaton.getTransitions())
+ for ( const std::pair<const ext::pair<StateType, InputSymbolType>, ext::set<StateType >>& transition : automaton.getTransitions())
if (transition.first.second == symbol)
return true;
@@ -594,7 +594,7 @@ public:
if ( automaton.getFinalStates ( ).count ( state ) )
return true;
- for (const std::pair<const std::pair<StateType, InputSymbolType>, ext::set<StateType > >& transition : automaton.getTransitions())
+ for ( const std::pair<const ext::pair<StateType, InputSymbolType>, ext::set<StateType > >& transition : automaton.getTransitions())
if (transition.first.first == state || transition.second.find(state) != transition.second.end())
return true;
diff --git a/alib2data/src/automaton/PDA/NPDA.h b/alib2data/src/automaton/PDA/NPDA.h
index 9ebc60a144ca0fd308f649c963cc7df9bedcc0cc..8e2a7feefd00f032e308764f4a688a44191ed053 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, ext::tuple < InputAlphabet >, ext::tuple < >, PushdownStoreSymbolType, ext::tuple < PushdownStoreAlphabet >, ext::tuple < InitialSymbol >, StateType, ext::tuple < States, FinalStates >, ext::tuple < InitialState > > {
protected:
- ext::map < ext::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector < PushdownStoreSymbolType > >, ext::set < std::pair < StateType, ext::vector < PushdownStoreSymbolType > > > > transitions;
+ ext::map < ext::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector < PushdownStoreSymbolType > >, ext::set < ext::pair < StateType, ext::vector < PushdownStoreSymbolType > > > > transitions;
public:
explicit NPDA ( ext::set < StateType > states, ext::set < InputSymbolType > inputAlphabet, ext::set < PushdownStoreSymbolType > pushdownStoreSymbol, StateType initialState, PushdownStoreSymbolType initialPushdownSymbol, ext::set < StateType > finalStates );
@@ -158,11 +158,11 @@ 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, ext::variant < EpsilonType, InputSymbolType > input, ext::vector < PushdownStoreSymbolType > pop, ext::set < std::pair < StateType, ext::vector < PushdownStoreSymbolType > > > targets );
+ void addTransitions ( StateType from, ext::variant < EpsilonType, InputSymbolType > input, ext::vector < PushdownStoreSymbolType > pop, ext::set < ext::pair < StateType, ext::vector < PushdownStoreSymbolType > > > targets );
- void addTransitions ( StateType from, InputSymbolType input, ext::vector < PushdownStoreSymbolType > pop, ext::set < std::pair < StateType, ext::vector < PushdownStoreSymbolType > > > targets );
+ void addTransitions ( StateType from, InputSymbolType input, ext::vector < PushdownStoreSymbolType > pop, ext::set < ext::pair < StateType, ext::vector < PushdownStoreSymbolType > > > targets );
- void addTransitions ( StateType from, ext::vector < PushdownStoreSymbolType > pop, ext::set < std::pair < StateType, ext::vector < PushdownStoreSymbolType > > > targets );
+ void addTransitions ( StateType from, ext::vector < PushdownStoreSymbolType > pop, ext::set < ext::pair < StateType, ext::vector < PushdownStoreSymbolType > > > targets );
/**
* Removes the transition from the NPDA.
@@ -178,7 +178,7 @@ public:
/**
* @return NPDA transitions
*/
- const ext::map < ext::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector < PushdownStoreSymbolType > >, ext::set < std::pair < StateType, ext::vector < PushdownStoreSymbolType > > > > & getTransitions ( ) const;
+ const ext::map < ext::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector < PushdownStoreSymbolType > >, ext::set < ext::pair < StateType, ext::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,10 +221,10 @@ 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 < ext::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector < PushdownStoreSymbolType > >, ext::set < std::pair < StateType, ext::vector < PushdownStoreSymbolType > > > > && transition : ext::make_moveable_map ( transitions ) ) {
- ext::set < std::pair < DefaultStateType, ext::vector < DefaultSymbolType > > > targets;
+ for ( std::pair < ext::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector < PushdownStoreSymbolType > >, ext::set < ext::pair < StateType, ext::vector < PushdownStoreSymbolType > > > > && transition : ext::make_moveable_map ( transitions ) ) {
+ ext::set < ext::pair < DefaultStateType, ext::vector < DefaultSymbolType > > > targets;
for ( std::pair < StateType, ext::vector < PushdownStoreSymbolType > > && target : ext::make_moveable_set ( transition.second ) )
- targets.insert ( std::make_pair ( AutomatonNormalize::normalizeState ( std::move ( target.first ) ), alphabet::SymbolNormalize::normalizeSymbols ( std::move ( target.second ) ) ) );
+ targets.insert ( ext::make_pair ( AutomatonNormalize::normalizeState ( std::move ( target.first ) ), alphabet::SymbolNormalize::normalizeSymbols ( std::move ( target.second ) ) ) );
ext::vector < DefaultSymbolType > pop = alphabet::SymbolNormalize::normalizeSymbols ( std::move ( std::get < 2 > ( transition.first ) ) );
DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( std::get < 0 > ( transition.first ) ) );
@@ -275,7 +275,7 @@ bool NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::
throw AutomatonException("Pushdown store symbol \"" + ext::to_string ( pushSymbol ) + "\" doesn't exist.");
ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector<PushdownStoreSymbolType> > key(std::move(from), std::move(input), std::move(pop));
- std::pair<StateType, ext::vector<PushdownStoreSymbolType> > value = std::make_pair(std::move(to), std::move(push));
+ ext::pair<StateType, ext::vector<PushdownStoreSymbolType> > value = ext::make_pair(std::move(to), std::move(push));
return transitions[std::move(key)].insert(std::move(value)).second;
}
@@ -293,7 +293,7 @@ bool NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-void NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransitions ( StateType from, ext::variant < EpsilonType, InputSymbolType > input, ext::vector < PushdownStoreSymbolType > pop, ext::set < std::pair < StateType, ext::vector < PushdownStoreSymbolType > > > targets ) {
+void NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransitions ( StateType from, ext::variant < EpsilonType, InputSymbolType > input, ext::vector < PushdownStoreSymbolType > pop, ext::set < ext::pair < StateType, ext::vector < PushdownStoreSymbolType > > > targets ) {
if (! getStates().count(from))
throw AutomatonException("State \"" + ext::to_string ( from ) + "\" doesn't exist.");
@@ -319,13 +319,13 @@ void NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-void NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransitions ( StateType from, InputSymbolType input, ext::vector < PushdownStoreSymbolType > pop, ext::set < std::pair < StateType, ext::vector < PushdownStoreSymbolType > > > targets ) {
+void NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransitions ( StateType from, InputSymbolType input, ext::vector < PushdownStoreSymbolType > pop, ext::set < ext::pair < StateType, ext::vector < PushdownStoreSymbolType > > > targets ) {
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, ext::vector < PushdownStoreSymbolType > pop, ext::set < std::pair < StateType, ext::vector < PushdownStoreSymbolType > > > targets ) {
+void NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransitions ( StateType from, ext::vector < PushdownStoreSymbolType > pop, ext::set < ext::pair < StateType, ext::vector < PushdownStoreSymbolType > > > targets ) {
auto inputVariant = ext::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
addTransitions ( std::move ( from ), std::move ( inputVariant ), std::move ( pop ), std::move ( targets ) );
}
@@ -333,7 +333,7 @@ void 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 ext::variant < EpsilonType, InputSymbolType > & input, const ext::vector<PushdownStoreSymbolType>& pop, const StateType& to, const ext::vector<PushdownStoreSymbolType>& push) {
ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector<PushdownStoreSymbolType> > key(from, input, pop);
- std::pair<StateType, ext::vector < PushdownStoreSymbolType > > value = std::make_pair(to, push);
+ ext::pair<StateType, ext::vector < PushdownStoreSymbolType > > value = ext::make_pair(to, push);
return transitions[key].erase(value);
}
@@ -351,7 +351,7 @@ bool NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-const ext::map<ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector<PushdownStoreSymbolType> >, ext::set<std::pair<StateType, ext::vector<PushdownStoreSymbolType> > > >& NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getTransitions() const {
+const ext::map<ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector<PushdownStoreSymbolType> >, ext::set<ext::pair<StateType, ext::vector<PushdownStoreSymbolType> > > >& NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getTransitions() const {
return transitions;
}
@@ -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 ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector<PushdownStoreSymbolType> >, ext::set<std::pair<StateType, ext::vector<PushdownStoreSymbolType> > > >& transition : automaton.getTransitions())
+ for ( const std::pair<const ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector<PushdownStoreSymbolType> >, ext::set<ext::pair<StateType, ext::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,12 +490,12 @@ public:
if(automaton.getInitialSymbol() == symbol)
return true;
- for (const std::pair<const ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector<PushdownStoreSymbolType> >, ext::set<std::pair<StateType, ext::vector<PushdownStoreSymbolType> > > >& transition : automaton.getTransitions()) {
+ for ( const std::pair<const ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector<PushdownStoreSymbolType> >, ext::set<ext::pair<StateType, ext::vector<PushdownStoreSymbolType> > > >& transition : automaton.getTransitions()) {
for (const PushdownStoreSymbolType& popSymbol : std::get<2>(transition.first))
if (symbol == popSymbol)
return true;
- for (const std::pair<StateType, ext::vector<PushdownStoreSymbolType> >& target : transition.second)
+ for ( const std::pair<StateType, ext::vector<PushdownStoreSymbolType> >& target : transition.second)
if (std::find(target.second.begin(), target.second.end(), symbol) != target.second.end())
return true;
}
@@ -532,10 +532,10 @@ public:
if ( automaton.getFinalStates ( ).count ( state ) )
return true;
- for (const std::pair<const ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector<PushdownStoreSymbolType> >, ext::set<std::pair<StateType, ext::vector<PushdownStoreSymbolType> > > >& transition : automaton.getTransitions()) {
+ for ( const std::pair<const ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector<PushdownStoreSymbolType> >, ext::set<ext::pair<StateType, ext::vector<PushdownStoreSymbolType> > > >& transition : automaton.getTransitions()) {
if (state == std::get<0>(transition.first))
return true;
- for(const std::pair<StateType, ext::vector<PushdownStoreSymbolType> >& target : transition.second)
+ for(const ext::pair<StateType, ext::vector<PushdownStoreSymbolType> >& target : transition.second)
if(target.first == state)
return true;
}
diff --git a/alib2data/src/automaton/PDA/NPDTA.h b/alib2data/src/automaton/PDA/NPDTA.h
index 55f78bda47c7861a0b0115f9cdd06545e03a1659..f13f6656551e7b1dbc1a0957a1c9dbb30ce2ea9e 100644
--- a/alib2data/src/automaton/PDA/NPDTA.h
+++ b/alib2data/src/automaton/PDA/NPDTA.h
@@ -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 ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector<PushdownStoreSymbolType> >, ext::set<ext::tuple<StateType, ext::vector<PushdownStoreSymbolType>, ext::vector < OutputSymbolType > > > >& transition : automaton.getTransitions())
+ for ( const std::pair<const ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector<PushdownStoreSymbolType> >, ext::set<ext::tuple<StateType, ext::vector<PushdownStoreSymbolType>, ext::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 ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector<PushdownStoreSymbolType> >, ext::set<ext::tuple<StateType, ext::vector<PushdownStoreSymbolType>, ext::vector < OutputSymbolType > > > >& transition : automaton.getTransitions())
+ for ( const std::pair<const ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector<PushdownStoreSymbolType> >, ext::set<ext::tuple<StateType, ext::vector<PushdownStoreSymbolType>, ext::vector < OutputSymbolType > > > >& transition : automaton.getTransitions())
for(const ext::tuple<StateType, ext::vector<PushdownStoreSymbolType>, ext::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 ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector<PushdownStoreSymbolType> >, ext::set<ext::tuple<StateType, ext::vector<PushdownStoreSymbolType>, ext::vector < OutputSymbolType > > > >& transition : automaton.getTransitions()) {
+ for ( const std::pair<const ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector<PushdownStoreSymbolType> >, ext::set<ext::tuple<StateType, ext::vector<PushdownStoreSymbolType>, ext::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 ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector<PushdownStoreSymbolType> >, ext::set<ext::tuple<StateType, ext::vector<PushdownStoreSymbolType>, ext::vector < OutputSymbolType > > > >& transition : automaton.getTransitions()) {
+ for ( const std::pair<const ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector<PushdownStoreSymbolType> >, ext::set<ext::tuple<StateType, ext::vector<PushdownStoreSymbolType>, ext::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 514c2631dffdfcb03173442ab09d5eb320a87510..10f7bcda8c14eebea1debc49a813fa4bab1d706a 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, ext::tuple < InputAlphabet >, ext::tuple < >, PushdownStoreSymbolType, ext::tuple < PushdownStoreAlphabet >, ext::tuple < BottomOfTheStackSymbol >, StateType, ext::tuple < States, FinalStates >, ext::tuple < InitialState > > {
protected:
- ext::map < std::pair < StateType, ext::variant < EpsilonType, InputSymbolType > >, std::pair < StateType, PushdownStoreSymbolType > > callTransitions;
+ ext::map < ext::pair < StateType, ext::variant < EpsilonType, InputSymbolType > >, ext::pair < StateType, PushdownStoreSymbolType > > callTransitions;
ext::map < ext::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, StateType > returnTransitions;
- ext::map < std::pair < StateType, ext::variant < EpsilonType, InputSymbolType > >, StateType > localTransitions;
+ ext::map < ext::pair < StateType, ext::variant < EpsilonType, InputSymbolType > >, StateType > localTransitions;
public:
explicit RealTimeHeightDeterministicDPDA ( ext::set < StateType > states, ext::set < InputSymbolType > inputAlphabet, ext::set < PushdownStoreSymbolType > pushdownStoreSymbol, StateType initialState, PushdownStoreSymbolType bottomOfTheStackSymbol, ext::set < StateType > finalStates );
@@ -202,11 +202,11 @@ public:
bool removeLocalTransition ( const StateType & current, const StateType & next );
bool removeLocalTransition ( const StateType & current, const InputSymbolType & input, const StateType & next );
- const ext::map < std::pair < StateType, ext::variant < EpsilonType, InputSymbolType > >, std::pair < StateType, PushdownStoreSymbolType > > & getCallTransitions ( ) const;
+ const ext::map < ext::pair < StateType, ext::variant < EpsilonType, InputSymbolType > >, ext::pair < StateType, PushdownStoreSymbolType > > & getCallTransitions ( ) const;
const ext::map < ext::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, StateType > & getReturnTransitions ( ) const;
- const ext::map < std::pair < StateType, ext::variant < EpsilonType, InputSymbolType > >, StateType > & getLocalTransitions ( ) const;
+ const ext::map < ext::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,7 +249,7 @@ 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, ext::variant < EpsilonType, InputSymbolType > >, std::pair < StateType, PushdownStoreSymbolType > > && transition : ext::make_moveable_map ( callTransitions ) ) {
+ for ( std::pair < ext::pair < StateType, ext::variant < EpsilonType, InputSymbolType > >, ext::pair < StateType, PushdownStoreSymbolType > > && transition : ext::make_moveable_map ( callTransitions ) ) {
DefaultStateType to = AutomatonNormalize::normalizeState ( std::move ( transition.second.first ) );
DefaultSymbolType push = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( transition.second.second ) );
@@ -269,7 +269,7 @@ public:
res->addReturnTransition ( std::move ( from ), std::move ( input ), std::move ( pop ), std::move ( to ) );
}
- for ( std::pair < std::pair < StateType, ext::variant < EpsilonType, InputSymbolType > >, StateType > && transition : ext::make_moveable_map ( localTransitions ) ) {
+ for ( std::pair < ext::pair < StateType, ext::variant < EpsilonType, InputSymbolType > >, StateType > && transition : ext::make_moveable_map ( localTransitions ) ) {
DefaultStateType to = AutomatonNormalize::normalizeState ( std::move ( transition.second ) );
DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) );
@@ -320,8 +320,8 @@ 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, 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));
+ ext::pair<StateType, ext::variant < EpsilonType, InputSymbolType >> key(std::move(from), std::move(input));
+ ext::pair<StateType, PushdownStoreSymbolType> value = ext::make_pair(std::move(to), std::move(push));
if(callTransitions.find(key) != callTransitions.end() && callTransitions.find(key)->second == value)
return false;
@@ -447,7 +447,7 @@ bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownSto
throw AutomatonException("State \"" + ext::to_string ( to ) + "\" doesn't exist.");
}
- std::pair<StateType, ext::variant < EpsilonType, InputSymbolType >> key(std::move(from), std::move(input));
+ ext::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;
@@ -496,8 +496,8 @@ 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 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);
+ ext::pair<StateType, ext::variant < EpsilonType, InputSymbolType >> key(from, input);
+ ext::pair<StateType, PushdownStoreSymbolType> value = ext::make_pair(to, push);
if (callTransitions.find(key) == callTransitions.end())
return false;
@@ -549,7 +549,7 @@ 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 ext::variant < EpsilonType, InputSymbolType >& input, const StateType& to) {
- std::pair<StateType, ext::variant < EpsilonType, InputSymbolType >> key(from, input);
+ ext::pair<StateType, ext::variant < EpsilonType, InputSymbolType >> key(from, input);
if (localTransitions.find(key) == localTransitions.end())
return false;
@@ -574,7 +574,7 @@ bool RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownSto
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-const ext::map<std::pair<StateType, ext::variant < EpsilonType, InputSymbolType >>, std::pair<StateType, PushdownStoreSymbolType> >& RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getCallTransitions() const {
+const ext::map<ext::pair<StateType, ext::variant < EpsilonType, InputSymbolType >>, ext::pair<StateType, PushdownStoreSymbolType> >& RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getCallTransitions() const {
return callTransitions;
}
@@ -584,7 +584,7 @@ const ext::map<ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-const ext::map<std::pair<StateType, ext::variant < EpsilonType, InputSymbolType >>, StateType>& RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getLocalTransitions() const {
+const ext::map<ext::pair<StateType, ext::variant < EpsilonType, InputSymbolType >>, StateType>& RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getLocalTransitions() const {
return localTransitions;
}
@@ -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, ext::variant < EpsilonType, InputSymbolType >>, std::pair<StateType, PushdownStoreSymbolType> >& callTransition : automaton.getCallTransitions())
+ for ( const std::pair<const ext::pair<StateType, ext::variant < EpsilonType, InputSymbolType >>, ext::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 ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, StateType>& returnTransition : automaton.getReturnTransitions())
+ for ( const std::pair<const ext::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, ext::variant < EpsilonType, InputSymbolType >>, StateType>& localTransition : automaton.getLocalTransitions())
+ for ( const std::pair<const ext::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, ext::variant < EpsilonType, InputSymbolType >>, std::pair<StateType, PushdownStoreSymbolType> >& callTransition : automaton.getCallTransitions())
+ for ( const std::pair<const ext::pair<StateType, ext::variant < EpsilonType, InputSymbolType >>, ext::pair<StateType, PushdownStoreSymbolType> >& callTransition : automaton.getCallTransitions())
if (symbol == callTransition.second.second)
return true;
- for (const std::pair<const ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, StateType>& returnTransition : automaton.getReturnTransitions())
+ for ( const std::pair<const ext::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, ext::variant < EpsilonType, InputSymbolType >>, std::pair<StateType, PushdownStoreSymbolType> >& callTransition : automaton.getCallTransitions())
+ for ( const std::pair<const ext::pair<StateType, ext::variant < EpsilonType, InputSymbolType >>, ext::pair<StateType, PushdownStoreSymbolType> >& callTransition : automaton.getCallTransitions())
if (state == callTransition.first.first || callTransition.second.first == state)
return true;
- for (const std::pair<const ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, StateType>& returnTransition : automaton.getReturnTransitions())
+ for ( const std::pair<const ext::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, ext::variant < EpsilonType, InputSymbolType >>, StateType>& localTransition : automaton.getLocalTransitions())
+ for ( const std::pair<const ext::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 e3bcb527f472deb9133001743dec5c0556db1d9c..585c63a2b98d82e195e95ba042d9269e5745e1d3 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, ext::tuple < InputAlphabet >, ext::tuple < >, PushdownStoreSymbolType, ext::tuple < PushdownStoreAlphabet >, ext::tuple < BottomOfTheStackSymbol >, StateType, ext::tuple < States, InitialStates, FinalStates >, ext::tuple < > > {
protected:
- ext::map < std::pair < StateType, ext::variant < EpsilonType, InputSymbolType > >, ext::set < std::pair < StateType, PushdownStoreSymbolType > > > callTransitions;
+ ext::map < ext::pair < StateType, ext::variant < EpsilonType, InputSymbolType > >, ext::set < ext::pair < StateType, PushdownStoreSymbolType > > > callTransitions;
ext::map < ext::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, ext::set < StateType > > returnTransitions;
- ext::map < std::pair < StateType, ext::variant < EpsilonType, InputSymbolType > >, ext::set < StateType > > localTransitions;
+ ext::map < ext::pair < StateType, ext::variant < EpsilonType, InputSymbolType > >, ext::set < StateType > > localTransitions;
public:
explicit RealTimeHeightDeterministicNPDA ( ext::set < StateType > states, ext::set < InputSymbolType > inputAlphabet, ext::set < PushdownStoreSymbolType > pushdownStoreSymbol, ext::set < StateType > initialStates, PushdownStoreSymbolType bottomOfTheStackSymbol, ext::set < StateType > finalStates );
@@ -190,9 +190,9 @@ 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, ext::variant < EpsilonType, InputSymbolType > input, ext::set < std::pair < StateType, PushdownStoreSymbolType > > targets );
- void addCallTransitions ( StateType current, ext::set < std::pair < StateType, PushdownStoreSymbolType > > targets );
- void addCallTransitions ( StateType current, InputSymbolType input, ext::set < std::pair < StateType, PushdownStoreSymbolType > > targets );
+ void addCallTransitions ( StateType current, ext::variant < EpsilonType, InputSymbolType > input, ext::set < ext::pair < StateType, PushdownStoreSymbolType > > targets );
+ void addCallTransitions ( StateType current, ext::set < ext::pair < StateType, PushdownStoreSymbolType > > targets );
+ void addCallTransitions ( StateType current, InputSymbolType input, ext::set < ext::pair < StateType, PushdownStoreSymbolType > > targets );
/**
* Adds return transition defined by parameters to the automaton.
@@ -243,11 +243,11 @@ public:
bool removeLocalTransition ( const StateType & current, const StateType & next );
bool removeLocalTransition ( const StateType & current, const InputSymbolType & input, const StateType & next );
- const ext::map < std::pair < StateType, ext::variant < EpsilonType, InputSymbolType > >, ext::set < std::pair < StateType, PushdownStoreSymbolType > > > & getCallTransitions ( ) const;
+ const ext::map < ext::pair < StateType, ext::variant < EpsilonType, InputSymbolType > >, ext::set < ext::pair < StateType, PushdownStoreSymbolType > > > & getCallTransitions ( ) const;
const ext::map < ext::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, ext::set < StateType > > & getReturnTransitions ( ) const;
- const ext::map < std::pair < StateType, ext::variant < EpsilonType, InputSymbolType > >, ext::set < StateType > > & getLocalTransitions ( ) const;
+ const ext::map < ext::pair < StateType, ext::variant < EpsilonType, InputSymbolType > >, ext::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,10 +290,10 @@ 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, ext::variant < EpsilonType, InputSymbolType > >, ext::set < std::pair < StateType, PushdownStoreSymbolType > > > && transition : ext::make_moveable_map ( callTransitions ) ) {
- ext::set < std::pair < DefaultStateType, DefaultSymbolType > > targets;
+ for ( std::pair < ext::pair < StateType, ext::variant < EpsilonType, InputSymbolType > >, ext::set < ext::pair < StateType, PushdownStoreSymbolType > > > && transition : ext::make_moveable_map ( callTransitions ) ) {
+ ext::set < ext::pair < DefaultStateType, DefaultSymbolType > > targets;
for ( std::pair < StateType, PushdownStoreSymbolType > && target : ext::make_moveable_set ( transition.second ) )
- targets.insert ( std::make_pair ( AutomatonNormalize::normalizeState ( std::move ( target.first ) ), alphabet::SymbolNormalize::normalizeSymbol ( std::move ( target.second ) ) ) );
+ targets.insert ( ext::make_pair ( AutomatonNormalize::normalizeState ( std::move ( target.first ) ), alphabet::SymbolNormalize::normalizeSymbol ( std::move ( target.second ) ) ) );
DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) );
ext::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( transition.first.second ) );
@@ -310,7 +310,7 @@ public:
res->addReturnTransitions ( std::move ( from ), std::move ( input ), std::move ( pop ), std::move ( targets ) );
}
- for ( std::pair < std::pair < StateType, ext::variant < EpsilonType, InputSymbolType > >, ext::set < StateType > > && transition : ext::make_moveable_map ( localTransitions ) ) {
+ for ( std::pair < ext::pair < StateType, ext::variant < EpsilonType, InputSymbolType > >, ext::set < StateType > > && transition : ext::make_moveable_map ( localTransitions ) ) {
ext::set < DefaultStateType > targets = AutomatonNormalize::normalizeStates ( std::move ( transition.second ) );
DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) );
@@ -359,8 +359,8 @@ bool RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownSto
throw AutomatonException("Pushdown store symbol \"" + ext::to_string ( push ) + "\" doesn't exist.");
}
- 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));
+ ext::pair<StateType, ext::variant < EpsilonType, InputSymbolType >> key(std::move(from), std::move(input));
+ ext::pair<StateType, PushdownStoreSymbolType> value = ext::make_pair(std::move(to), std::move(push));
return callTransitions[std::move(key)].insert(std::move(value)).second;
}
@@ -426,7 +426,7 @@ bool RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownSto
throw AutomatonException("State \"" + ext::to_string ( to ) + "\" doesn't exist.");
}
- std::pair<StateType, ext::variant < EpsilonType, InputSymbolType >> key(std::move(from), std::move(input));
+ ext::pair<StateType, ext::variant < EpsilonType, InputSymbolType >> key(std::move(from), std::move(input));
return localTransitions[std::move(key)].insert(std::move(to)).second;
}
@@ -444,7 +444,7 @@ bool RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownSto
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-void RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addCallTransitions(StateType from, ext::variant < EpsilonType, InputSymbolType > input, ext::set < std::pair < StateType, PushdownStoreSymbolType > > targets ) {
+void RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addCallTransitions(StateType from, ext::variant < EpsilonType, InputSymbolType > input, ext::set < ext::pair < StateType, PushdownStoreSymbolType > > targets ) {
if (! getStates().count(from))
throw AutomatonException("State \"" + ext::to_string ( from ) + "\" doesn't exist.");
@@ -459,18 +459,18 @@ void RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownSto
throw AutomatonException("Pushdown store symbol \"" + ext::to_string ( target.second ) + "\" doesn't exist.");
}
- std::pair < StateType, ext::variant < EpsilonType, InputSymbolType > > key ( std::move ( from ), std::move ( input ) );
+ ext::pair < StateType, ext::variant < EpsilonType, InputSymbolType > > key ( std::move ( from ), std::move ( input ) );
callTransitions [ std::move ( key ) ].insert ( ext::make_moveable_set ( targets ).begin ( ), ext::make_moveable_set ( targets ).end ( ) );
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-void RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addCallTransitions(StateType from, ext::set < std::pair < StateType, PushdownStoreSymbolType > > targets ) {
+void RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addCallTransitions(StateType from, ext::set < ext::pair < StateType, PushdownStoreSymbolType > > targets ) {
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, ext::set < std::pair < StateType, PushdownStoreSymbolType > > targets ) {
+void RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addCallTransitions(StateType from, InputSymbolType input, ext::set < ext::pair < StateType, PushdownStoreSymbolType > > targets ) {
ext::variant < EpsilonType, InputSymbolType > inputVariant(input);
addCallTransitions(std::move(from), std::move(inputVariant), std::move ( targets ) );
}
@@ -516,7 +516,7 @@ 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, ext::variant < EpsilonType, InputSymbolType >> key(std::move(from), std::move(input));
+ ext::pair<StateType, ext::variant < EpsilonType, InputSymbolType >> key(std::move(from), std::move(input));
localTransitions[std::move(key)].insert ( ext::make_moveable_set ( to ).begin ( ), ext::make_moveable_set ( to ).end ( ) );
}
@@ -534,8 +534,8 @@ void RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownSto
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
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);
+ ext::pair<StateType, ext::variant < EpsilonType, InputSymbolType >> key(from, input);
+ ext::pair<StateType, PushdownStoreSymbolType> value = ext::make_pair(to, push);
return callTransitions[key].erase(value);
}
@@ -573,7 +573,7 @@ bool RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownSto
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
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);
+ ext::pair<StateType, ext::variant < EpsilonType, InputSymbolType >> key(from, input);
return localTransitions[key].erase(to);
}
@@ -591,7 +591,7 @@ bool RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownSto
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-const ext::map<std::pair<StateType, ext::variant < EpsilonType, InputSymbolType >>, ext::set<std::pair<StateType, PushdownStoreSymbolType> > >& RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getCallTransitions() const {
+const ext::map<ext::pair<StateType, ext::variant < EpsilonType, InputSymbolType >>, ext::set<ext::pair<StateType, PushdownStoreSymbolType> > >& RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getCallTransitions() const {
return callTransitions;
}
@@ -601,7 +601,7 @@ const ext::map<ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-const ext::map<std::pair<StateType, ext::variant < EpsilonType, InputSymbolType >>, ext::set<StateType> >& RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getLocalTransitions() const {
+const ext::map<ext::pair<StateType, ext::variant < EpsilonType, InputSymbolType >>, ext::set<StateType> >& RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getLocalTransitions() const {
return localTransitions;
}
@@ -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, ext::variant < EpsilonType, InputSymbolType >>, ext::set<std::pair<StateType, PushdownStoreSymbolType> > >& callTransition : automaton.getCallTransitions())
+ for ( const std::pair<const ext::pair<StateType, ext::variant < EpsilonType, InputSymbolType >>, ext::set<ext::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 ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, ext::set<StateType> >& returnTransition : automaton.getReturnTransitions())
+ for ( const std::pair<const ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, ext::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, ext::variant < EpsilonType, InputSymbolType >>, ext::set<StateType> >& localTransition : automaton.getLocalTransitions())
+ for ( const std::pair<const ext::pair<StateType, ext::variant < EpsilonType, InputSymbolType >>, ext::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, ext::variant < EpsilonType, InputSymbolType >>, ext::set<std::pair<StateType, PushdownStoreSymbolType> > >& callTransition : automaton.getCallTransitions())
- for(const std::pair<StateType, PushdownStoreSymbolType>& to : callTransition.second)
+ for ( const std::pair<const ext::pair<StateType, ext::variant < EpsilonType, InputSymbolType >>, ext::set<ext::pair<StateType, PushdownStoreSymbolType> > >& callTransition : automaton.getCallTransitions())
+ for(const ext::pair<StateType, PushdownStoreSymbolType>& to : callTransition.second)
if (symbol == to.second)
return true;
- for (const std::pair<const ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, ext::set<StateType> >& returnTransition : automaton.getReturnTransitions())
+ for ( const std::pair<const ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, ext::set<StateType> >& returnTransition : automaton.getReturnTransitions())
if (symbol == std::get<2>(returnTransition.first))
return true;
@@ -831,16 +831,16 @@ public:
if ( automaton.getFinalStates ( ).count ( state ) )
return true;
- for (const std::pair<const std::pair<StateType, ext::variant < EpsilonType, InputSymbolType >>, ext::set<std::pair<StateType, PushdownStoreSymbolType> > >& callTransition : automaton.getCallTransitions()) {
+ for ( const std::pair<const ext::pair<StateType, ext::variant < EpsilonType, InputSymbolType >>, ext::set<ext::pair<StateType, PushdownStoreSymbolType> > >& callTransition : automaton.getCallTransitions()) {
if (state == callTransition.first.first)
return true;
- for(const std::pair<StateType, PushdownStoreSymbolType>& target : callTransition.second)
+ for(const ext::pair<StateType, PushdownStoreSymbolType>& target : callTransition.second)
if(target.first == state)
return true;
}
- for (const std::pair<const ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, ext::set<StateType> >& returnTransition : automaton.getReturnTransitions()) {
+ for ( const std::pair<const ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, ext::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, ext::variant < EpsilonType, InputSymbolType >>, ext::set<StateType> >& localTransition : automaton.getLocalTransitions()) {
+ for ( const std::pair<const ext::pair<StateType, ext::variant < EpsilonType, InputSymbolType >>, ext::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 0eda469e56e7879a5187a672d46860940075e12c..dd1d1fc33b3e4fed4d6b21cdc846cd3a6cb87fa5 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, ext::tuple < InputAlphabet >, ext::tuple < >, PushdownStoreSymbolType, ext::tuple < PushdownStoreAlphabet >, ext::tuple < InitialSymbol >, StateType, ext::tuple < States, FinalStates >, ext::tuple < InitialState > > {
protected:
- ext::map < ext::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, std::pair < StateType, ext::vector < PushdownStoreSymbolType > > > transitions;
+ ext::map < ext::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, ext::pair < StateType, ext::vector < PushdownStoreSymbolType > > > transitions;
public:
explicit SinglePopDPDA ( ext::set < StateType > states, ext::set < InputSymbolType > inputAlphabet, ext::set < PushdownStoreSymbolType > pushdownStoreSymbol, StateType initialState, PushdownStoreSymbolType initialPushdownSymbol, ext::set < StateType > finalStates );
@@ -171,7 +171,7 @@ public:
/**
* @return SinglePopDPDA transitions
*/
- const ext::map < ext::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, std::pair < StateType, ext::vector < PushdownStoreSymbolType > > > & getTransitions ( ) const;
+ const ext::map < ext::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, ext::pair < StateType, ext::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,7 +214,7 @@ 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 < ext::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, std::pair < StateType, ext::vector < PushdownStoreSymbolType > > > && transition : ext::make_moveable_map ( transitions ) ) {
+ for ( std::pair < ext::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, ext::pair < StateType, ext::vector < PushdownStoreSymbolType > > > && transition : ext::make_moveable_map ( transitions ) ) {
DefaultStateType to = AutomatonNormalize::normalizeState ( std::move ( transition.second.first ) );
ext::vector < DefaultSymbolType > push = alphabet::SymbolNormalize::normalizeSymbols ( std::move ( transition.second.second ) );
@@ -272,7 +272,7 @@ bool SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, Stat
}
ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType> key(std::move(from), std::move(input), std::move(pop));
- std::pair<StateType, ext::vector<PushdownStoreSymbolType> > value = std::make_pair(std::move(to), std::move(push));
+ ext::pair<StateType, ext::vector<PushdownStoreSymbolType> > value = ext::make_pair(std::move(to), std::move(push));
if (transitions.find(key) != transitions.end()) {
if(transitions.find(key)->second == value)
@@ -284,7 +284,7 @@ bool SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, Stat
}
if(input.template is<EpsilonType>()) {
- if(std::any_of(transitions.begin(), transitions.end(), [&](const std::pair<ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, std::pair<StateType, ext::vector<PushdownStoreSymbolType> > > & transition) {
+ if(std::any_of(transitions.begin(), transitions.end(), [&](const std::pair<ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, ext::pair<StateType, ext::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;
}))
@@ -314,7 +314,7 @@ 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 ext::variant < EpsilonType, InputSymbolType >& input, const PushdownStoreSymbolType& pop, const StateType& to, const ext::vector<PushdownStoreSymbolType>& push) {
ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType> key(from, input, pop);
- std::pair<StateType, ext::vector<PushdownStoreSymbolType> > value = std::make_pair(to, push);
+ ext::pair<StateType, ext::vector<PushdownStoreSymbolType> > value = ext::make_pair(to, push);
if (transitions.find(key) == transitions.end())
return false;
@@ -343,7 +343,7 @@ bool SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, Stat
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-const ext::map<ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, std::pair<StateType, ext::vector<PushdownStoreSymbolType> > >& SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getTransitions() const {
+const ext::map<ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, ext::pair<StateType, ext::vector<PushdownStoreSymbolType> > >& SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getTransitions() const {
return transitions;
}
@@ -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 ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, std::pair<StateType, ext::vector<PushdownStoreSymbolType> > >& transition : automaton.getTransitions())
+ for ( const std::pair<const ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, ext::pair<StateType, ext::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 ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, std::pair<StateType, ext::vector<PushdownStoreSymbolType> > >& transition : automaton.getTransitions())
+ for ( const std::pair<const ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, ext::pair<StateType, ext::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 ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, std::pair<StateType, ext::vector<PushdownStoreSymbolType> > >& transition : automaton.getTransitions())
+ for ( const std::pair<const ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, ext::pair<StateType, ext::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 84a798622d194cad7bd8131593077f8bda2477af..fcd24d0b038c506d37e52223ed6c04adac0061ff 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, ext::tuple < InputAlphabet >, ext::tuple < >, PushdownStoreSymbolType, ext::tuple < PushdownStoreAlphabet >, ext::tuple < InitialSymbol >, StateType, ext::tuple < States, FinalStates >, ext::tuple < InitialState > > {
protected:
- ext::map < ext::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, ext::set < std::pair < StateType, ext::vector < PushdownStoreSymbolType > > > > transitions;
+ ext::map < ext::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, ext::set < ext::pair < StateType, ext::vector < PushdownStoreSymbolType > > > > transitions;
public:
explicit SinglePopNPDA ( ext::set < StateType > states, ext::set < InputSymbolType > inputAlphabet, ext::set < PushdownStoreSymbolType > pushdownStoreSymbol, StateType initialState, PushdownStoreSymbolType initialPushdownSymbol, ext::set < StateType > finalStates );
@@ -158,11 +158,11 @@ 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, ext::variant < EpsilonType, InputSymbolType > input, PushdownStoreSymbolType pop, ext::set < std::pair < StateType, ext::vector < PushdownStoreSymbolType > > > push );
+ void addTransitions ( StateType from, ext::variant < EpsilonType, InputSymbolType > input, PushdownStoreSymbolType pop, ext::set < ext::pair < StateType, ext::vector < PushdownStoreSymbolType > > > push );
- void addTransitions ( StateType from, InputSymbolType input, PushdownStoreSymbolType pop, ext::set < std::pair < StateType, ext::vector < PushdownStoreSymbolType > > > push );
+ void addTransitions ( StateType from, InputSymbolType input, PushdownStoreSymbolType pop, ext::set < ext::pair < StateType, ext::vector < PushdownStoreSymbolType > > > push );
- void addTransitions ( StateType from, PushdownStoreSymbolType pop, ext::set < std::pair < StateType, ext::vector < PushdownStoreSymbolType > > > push );
+ void addTransitions ( StateType from, PushdownStoreSymbolType pop, ext::set < ext::pair < StateType, ext::vector < PushdownStoreSymbolType > > > push );
/**
* Removes the transition from the SinglePopNPDA.
@@ -178,7 +178,7 @@ public:
/**
* @return SinglePopNPDA transitions
*/
- const ext::map < ext::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, ext::set < std::pair < StateType, ext::vector < PushdownStoreSymbolType > > > > & getTransitions ( ) const;
+ const ext::map < ext::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, ext::set < ext::pair < StateType, ext::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,10 +221,10 @@ 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 < ext::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, ext::set < std::pair < StateType, ext::vector < PushdownStoreSymbolType > > > > && transition : ext::make_moveable_map ( transitions ) ) {
- ext::set < std::pair < DefaultStateType, ext::vector < DefaultSymbolType > > > targets;
+ for ( std::pair < ext::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, ext::set < ext::pair < StateType, ext::vector < PushdownStoreSymbolType > > > > && transition : ext::make_moveable_map ( transitions ) ) {
+ ext::set < ext::pair < DefaultStateType, ext::vector < DefaultSymbolType > > > targets;
for ( std::pair < StateType, ext::vector < PushdownStoreSymbolType > > && target : ext::make_moveable_set ( transition.second ) )
- targets.insert ( std::make_pair ( AutomatonNormalize::normalizeState ( std::move ( target.first ) ), alphabet::SymbolNormalize::normalizeSymbols ( std::move ( target.second ) ) ) );
+ targets.insert ( ext::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 ) ) );
@@ -280,7 +280,7 @@ bool SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, Stat
}
ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType> key(std::move(from), std::move(input), std::move(pop));
- std::pair<StateType, ext::vector<PushdownStoreSymbolType> > value = std::make_pair(std::move(to), std::move(push));
+ ext::pair<StateType, ext::vector<PushdownStoreSymbolType> > value = ext::make_pair(std::move(to), std::move(push));
return transitions[std::move(key)].insert(std::move(value)).second;
}
@@ -298,7 +298,7 @@ bool SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, Stat
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-void SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransitions(StateType from, ext::variant < EpsilonType, InputSymbolType > input, PushdownStoreSymbolType pop, ext::set < std::pair < StateType, ext::vector < PushdownStoreSymbolType > > > targets ) {
+void SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransitions(StateType from, ext::variant < EpsilonType, InputSymbolType > input, PushdownStoreSymbolType pop, ext::set < ext::pair < StateType, ext::vector < PushdownStoreSymbolType > > > targets ) {
if (! getStates().count(from))
throw AutomatonException("State \"" + ext::to_string ( from ) + "\" doesn't exist.");
@@ -322,13 +322,13 @@ void SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, Stat
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-void SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransitions(StateType from, InputSymbolType input, PushdownStoreSymbolType pop, ext::set < std::pair < StateType, ext::vector < PushdownStoreSymbolType > > > targets) {
+void SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransitions(StateType from, InputSymbolType input, PushdownStoreSymbolType pop, ext::set < ext::pair < StateType, ext::vector < PushdownStoreSymbolType > > > targets) {
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, ext::set < std::pair < StateType, ext::vector < PushdownStoreSymbolType > > >targets ) {
+void SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::addTransitions(StateType from, PushdownStoreSymbolType pop, ext::set < ext::pair < StateType, ext::vector < PushdownStoreSymbolType > > >targets ) {
auto inputVariant = ext::variant < EpsilonType, InputSymbolType >::template from < EpsilonType > ( );
addTransitions(std::move(from), std::move(inputVariant), std::move(pop), std::move ( targets ) );
}
@@ -336,7 +336,7 @@ void 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 ext::variant < EpsilonType, InputSymbolType >& input, const PushdownStoreSymbolType& pop, const StateType& to, const ext::vector<PushdownStoreSymbolType>& push) {
ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType> key(from, input, pop);
- std::pair<StateType, ext::vector<PushdownStoreSymbolType> > value = std::make_pair(to, push);
+ ext::pair<StateType, ext::vector<PushdownStoreSymbolType> > value = ext::make_pair(to, push);
return transitions[key].erase(value);
}
@@ -354,7 +354,7 @@ bool SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, Stat
}
template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-const ext::map<ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, ext::set<std::pair<StateType, ext::vector<PushdownStoreSymbolType> > > >& SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getTransitions() const {
+const ext::map<ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, ext::set<ext::pair<StateType, ext::vector<PushdownStoreSymbolType> > > >& SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::getTransitions() const {
return transitions;
}
@@ -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 ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, ext::set<std::pair<StateType, ext::vector<PushdownStoreSymbolType> > > >& transition : automaton.getTransitions())
+ for ( const std::pair<const ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, ext::set<ext::pair<StateType, ext::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,11 +493,11 @@ public:
if(automaton.getInitialSymbol() == symbol)
return true;
- for (const std::pair<const ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, ext::set<std::pair<StateType, ext::vector<PushdownStoreSymbolType> > > >& transition : automaton.getTransitions()) {
+ for ( const std::pair<const ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, ext::set<ext::pair<StateType, ext::vector<PushdownStoreSymbolType> > > >& transition : automaton.getTransitions()) {
if (symbol == std::get<2>(transition.first))
return true;
- for (const std::pair<StateType, ext::vector<PushdownStoreSymbolType> >& target : transition.second)
+ for ( const std::pair<StateType, ext::vector<PushdownStoreSymbolType> >& target : transition.second)
if (std::find(target.second.begin(), target.second.end(), symbol) != target.second.end())
return true;
}
@@ -534,11 +534,11 @@ public:
if ( automaton.getFinalStates ( ).count ( state ) )
return true;
- for (const std::pair<const ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, ext::set<std::pair<StateType, ext::vector<PushdownStoreSymbolType> > > >& transition : automaton.getTransitions()) {
+ for ( const std::pair<const ext::tuple<StateType, ext::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType>, ext::set<ext::pair<StateType, ext::vector<PushdownStoreSymbolType> > > >& transition : automaton.getTransitions()) {
if (state == std::get<0>(transition.first))
return true;
- for(const std::pair<StateType, ext::vector<PushdownStoreSymbolType> >& target : transition.second)
+ for(const ext::pair<StateType, ext::vector<PushdownStoreSymbolType> >& target : transition.second)
if(target.first == state)
return true;
}
diff --git a/alib2data/src/automaton/PDA/VisiblyPushdownDPDA.h b/alib2data/src/automaton/PDA/VisiblyPushdownDPDA.h
index 1537cf331f16bb73b363cc3da8954ee804ad4e0b..70a62bb28e531462eaa5e7261d26d03b1d06681c 100644
--- a/alib2data/src/automaton/PDA/VisiblyPushdownDPDA.h
+++ b/alib2data/src/automaton/PDA/VisiblyPushdownDPDA.h
@@ -43,9 +43,9 @@ class InitialState;
template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
class VisiblyPushdownDPDA final : public AutomatonBase, public alib::Components < VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >, PushdownStoreSymbolType, ext::tuple < CallAlphabet, ReturnAlphabet, LocalAlphabet >, ext::tuple < >, PushdownStoreSymbolType, ext::tuple < PushdownStoreAlphabet >, ext::tuple < BottomOfTheStackSymbol >, StateType, ext::tuple < States, FinalStates >, ext::tuple < InitialState > > {
protected:
- ext::map < std::pair < StateType, InputSymbolType >, std::pair < StateType, PushdownStoreSymbolType > > callTransitions;
+ ext::map < ext::pair < StateType, InputSymbolType >, ext::pair < StateType, PushdownStoreSymbolType > > callTransitions;
ext::map < ext::tuple < StateType, InputSymbolType, PushdownStoreSymbolType >, StateType > returnTransitions;
- ext::map < std::pair < StateType, InputSymbolType >, StateType > localTransitions;
+ ext::map < ext::pair < StateType, InputSymbolType >, StateType > localTransitions;
public:
explicit VisiblyPushdownDPDA ( ext::set < StateType > states, ext::set < InputSymbolType > callAlphabet, ext::set < InputSymbolType > returnAlphabet, ext::set < InputSymbolType > localAlphabet, ext::set < PushdownStoreSymbolType > pushdownStoreSymbol, StateType initialState, PushdownStoreSymbolType bottomOfTheStackSymbol, ext::set < StateType > finalStates );
@@ -235,11 +235,11 @@ public:
*/
bool removeLocalTransition ( const StateType & current, const InputSymbolType & input, const StateType & next );
- const ext::map < std::pair < StateType, InputSymbolType >, std::pair < StateType, PushdownStoreSymbolType > > & getCallTransitions ( ) const;
+ const ext::map < ext::pair < StateType, InputSymbolType >, ext::pair < StateType, PushdownStoreSymbolType > > & getCallTransitions ( ) const;
const ext::map < ext::tuple < StateType, InputSymbolType, PushdownStoreSymbolType >, StateType > & getReturnTransitions ( ) const;
- const ext::map < std::pair < StateType, InputSymbolType >, StateType > & getLocalTransitions ( ) const;
+ const ext::map < ext::pair < StateType, 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 );
@@ -284,7 +284,7 @@ public:
VisiblyPushdownDPDA < > * res = new VisiblyPushdownDPDA < > ( std::move ( states ), std::move ( call_alphabet ), std::move ( return_alphabet ), std::move ( local_alphabet ), std::move ( pushdownAlphabet ), std::move ( initialState ), std::move ( bottomSymbol ), std::move ( finalStates ) );
- for ( std::pair < std::pair < StateType, InputSymbolType >, std::pair < StateType, PushdownStoreSymbolType > > && transition : ext::make_moveable_map ( callTransitions ) ) {
+ for ( std::pair < ext::pair < StateType, InputSymbolType >, ext::pair < StateType, PushdownStoreSymbolType > > && transition : ext::make_moveable_map ( callTransitions ) ) {
DefaultStateType to = AutomatonNormalize::normalizeState ( std::move ( transition.second.first ) );
DefaultSymbolType push = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( transition.second.second ) );
@@ -304,7 +304,7 @@ public:
res->addReturnTransition ( std::move ( from ), std::move ( input ), std::move ( pop ), std::move ( to ) );
}
- for ( std::pair < std::pair < StateType, InputSymbolType >, StateType > && transition : ext::make_moveable_map ( localTransitions ) ) {
+ for ( std::pair < ext::pair < StateType, InputSymbolType >, StateType > && transition : ext::make_moveable_map ( localTransitions ) ) {
DefaultStateType to = AutomatonNormalize::normalizeState ( std::move ( transition.second ) );
DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) );
@@ -353,8 +353,8 @@ bool VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >
throw AutomatonException("Pushdown store symbol \"" + ext::to_string ( push ) + "\" doesn't exist.");
}
- std::pair<StateType, InputSymbolType> key(std::move(from), std::move(input));
- std::pair<StateType, PushdownStoreSymbolType> value = std::make_pair(std::move(to), std::move(push));
+ ext::pair<StateType, InputSymbolType> key(std::move(from), std::move(input));
+ ext::pair<StateType, PushdownStoreSymbolType> value = ext::make_pair(std::move(to), std::move(push));
if(callTransitions.find(key) != callTransitions.end() && callTransitions.find(key)->second == value)
return false;
@@ -428,7 +428,7 @@ bool VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >
throw AutomatonException("State \"" + ext::to_string ( to ) + "\" doesn't exist.");
}
- std::pair<StateType, InputSymbolType> key(std::move(from), std::move(input));
+ ext::pair<StateType, InputSymbolType> key(std::move(from), std::move(input));
if(localTransitions.find(key) != localTransitions.end() && localTransitions.find(key)->second == to)
return false;
@@ -451,8 +451,8 @@ bool VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >
template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
bool VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::removeCallTransition(const StateType& from, const InputSymbolType& input, const StateType& to, const PushdownStoreSymbolType& push) {
- std::pair<StateType, InputSymbolType> key(from, input);
- std::pair<StateType, PushdownStoreSymbolType> value = std::make_pair(to, push);
+ ext::pair<StateType, InputSymbolType> key(from, input);
+ ext::pair<StateType, PushdownStoreSymbolType> value = ext::make_pair(to, push);
if (callTransitions.find(key) == callTransitions.end())
return false;
@@ -480,7 +480,7 @@ bool VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >
template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
bool VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::removeLocalTransition(const StateType& from, const InputSymbolType& input, const StateType& to) {
- std::pair<StateType, InputSymbolType> key(from, input);
+ ext::pair<StateType, InputSymbolType> key(from, input);
if (localTransitions.find(key) == localTransitions.end())
return false;
@@ -493,7 +493,7 @@ bool VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >
}
template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
-const ext::map<std::pair<StateType, InputSymbolType>, std::pair<StateType, PushdownStoreSymbolType> >& VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::getCallTransitions() const {
+const ext::map<ext::pair<StateType, InputSymbolType>, ext::pair<StateType, PushdownStoreSymbolType> >& VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::getCallTransitions() const {
return callTransitions;
}
@@ -503,7 +503,7 @@ const ext::map<ext::tuple<StateType, InputSymbolType, PushdownStoreSymbolType>,
}
template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
-const ext::map<std::pair<StateType, InputSymbolType>, StateType>& VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::getLocalTransitions() const {
+const ext::map<ext::pair<StateType, InputSymbolType>, StateType>& VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::getLocalTransitions() const {
return localTransitions;
}
@@ -663,7 +663,7 @@ template < class InputSymbolType, class PushdownStoreSymbolType, class StateType
class ComponentConstraint< automaton::VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >, InputSymbolType, automaton::CallAlphabet > {
public:
static bool used ( const automaton::VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & automaton, const InputSymbolType & symbol ) {
- for (const std::pair<const std::pair<StateType, InputSymbolType>, std::pair<StateType, PushdownStoreSymbolType> >& callTransition : automaton.getCallTransitions())
+ for ( const std::pair<const ext::pair<StateType, InputSymbolType>, ext::pair<StateType, PushdownStoreSymbolType> >& callTransition : automaton.getCallTransitions())
if (symbol == callTransition.first.second)
return true;
@@ -686,7 +686,7 @@ template < class InputSymbolType, class PushdownStoreSymbolType, class StateType
class ComponentConstraint< automaton::VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >, InputSymbolType, automaton::ReturnAlphabet > {
public:
static bool used ( const automaton::VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & automaton, const InputSymbolType & symbol ) {
- for (const std::pair<const ext::tuple<StateType, InputSymbolType, PushdownStoreSymbolType>, StateType>& returnTransition : automaton.getReturnTransitions())
+ for ( const std::pair<const ext::tuple<StateType, InputSymbolType, PushdownStoreSymbolType>, StateType>& returnTransition : automaton.getReturnTransitions())
if (symbol == std::get<1>(returnTransition.first))
return true;
@@ -709,7 +709,7 @@ template < class InputSymbolType, class PushdownStoreSymbolType, class StateType
class ComponentConstraint< automaton::VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >, InputSymbolType, automaton::LocalAlphabet > {
public:
static bool used ( const automaton::VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & automaton, const InputSymbolType & symbol ) {
- for (const std::pair<const std::pair<StateType, InputSymbolType>, StateType>& localTransition : automaton.getLocalTransitions())
+ for ( const std::pair<const ext::pair<StateType, InputSymbolType>, StateType>& localTransition : automaton.getLocalTransitions())
if (symbol == localTransition.first.second)
return true;
@@ -732,11 +732,11 @@ template < class InputSymbolType, class PushdownStoreSymbolType, class StateType
class ComponentConstraint< automaton::VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >, PushdownStoreSymbolType, automaton::PushdownStoreAlphabet > {
public:
static bool used ( const automaton::VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & automaton, const PushdownStoreSymbolType & symbol ) {
- for (const std::pair<const std::pair<StateType, InputSymbolType>, std::pair<StateType, PushdownStoreSymbolType> >& callTransition : automaton.getCallTransitions())
+ for ( const std::pair<const ext::pair<StateType, InputSymbolType>, ext::pair<StateType, PushdownStoreSymbolType> >& callTransition : automaton.getCallTransitions())
if (symbol == callTransition.second.second)
return true;
- for (const std::pair<const ext::tuple<StateType, InputSymbolType, PushdownStoreSymbolType>, StateType>& returnTransition : automaton.getReturnTransitions())
+ for ( const std::pair<const ext::tuple<StateType, InputSymbolType, PushdownStoreSymbolType>, StateType>& returnTransition : automaton.getReturnTransitions())
if (symbol == std::get<2>(returnTransition.first))
return true;
@@ -775,15 +775,15 @@ public:
if ( automaton.getFinalStates ( ).count ( state ) )
return true;
- for (const std::pair<const std::pair<StateType, InputSymbolType>, std::pair<StateType, PushdownStoreSymbolType> >& callTransition : automaton.getCallTransitions())
+ for ( const std::pair<const ext::pair<StateType, InputSymbolType>, ext::pair<StateType, PushdownStoreSymbolType> >& callTransition : automaton.getCallTransitions())
if (state == callTransition.first.first || callTransition.second.first == state)
return true;
- for (const std::pair<const ext::tuple<StateType, InputSymbolType, PushdownStoreSymbolType>, StateType>& returnTransition : automaton.getReturnTransitions())
+ for ( const std::pair<const ext::tuple<StateType, 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, InputSymbolType>, StateType>& localTransition : automaton.getLocalTransitions())
+ for ( const std::pair<const ext::pair<StateType, InputSymbolType>, StateType>& localTransition : automaton.getLocalTransitions())
if (state == localTransition.first.first || localTransition.second == state)
return true;
diff --git a/alib2data/src/automaton/PDA/VisiblyPushdownNPDA.h b/alib2data/src/automaton/PDA/VisiblyPushdownNPDA.h
index e5dc3d28bacd2263d7bb2d393a2f162047ca63d5..3466ed07bf4e6411bb9613748b2ae9602d798531 100644
--- a/alib2data/src/automaton/PDA/VisiblyPushdownNPDA.h
+++ b/alib2data/src/automaton/PDA/VisiblyPushdownNPDA.h
@@ -43,9 +43,9 @@ class InitialStates;
template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
class VisiblyPushdownNPDA final : public AutomatonBase, public alib::Components < VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >, InputSymbolType, ext::tuple < CallAlphabet, ReturnAlphabet, LocalAlphabet >, ext::tuple < >, PushdownStoreSymbolType, ext::tuple < PushdownStoreAlphabet >, ext::tuple < BottomOfTheStackSymbol >, StateType, ext::tuple < States, InitialStates, FinalStates >, ext::tuple < > > {
protected:
- ext::map < std::pair < StateType, InputSymbolType >, ext::set < std::pair < StateType, PushdownStoreSymbolType > > > callTransitions;
+ ext::map < ext::pair < StateType, InputSymbolType >, ext::set < ext::pair < StateType, PushdownStoreSymbolType > > > callTransitions;
ext::map < ext::tuple < StateType, InputSymbolType, PushdownStoreSymbolType >, ext::set < StateType > > returnTransitions;
- ext::map < std::pair < StateType, InputSymbolType >, ext::set < StateType > > localTransitions;
+ ext::map < ext::pair < StateType, InputSymbolType >, ext::set < StateType > > localTransitions;
public:
explicit VisiblyPushdownNPDA ( ext::set < StateType > states, ext::set < InputSymbolType > callAlphabet, ext::set < InputSymbolType > returnAlphabet, ext::set < InputSymbolType > localAlphabet, ext::set < PushdownStoreSymbolType > pushdownStoreSymbol, ext::set < StateType > initialStates, PushdownStoreSymbolType bottomOfTheStackSymbol, ext::set < StateType > finalStates );
@@ -229,7 +229,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, InputSymbolType input, ext::set < std::pair < StateType, PushdownStoreSymbolType > > targets );
+ void addCallTransitions ( StateType current, InputSymbolType input, ext::set < ext::pair < StateType, PushdownStoreSymbolType > > targets );
/**
* Adds return transition defined by parameters to the automaton.
@@ -270,11 +270,11 @@ public:
*/
bool removeLocalTransition ( const StateType & current, const InputSymbolType & input, const StateType & next );
- const ext::map < std::pair < StateType, InputSymbolType >, ext::set < std::pair < StateType, PushdownStoreSymbolType > > > & getCallTransitions ( ) const;
+ const ext::map < ext::pair < StateType, InputSymbolType >, ext::set < ext::pair < StateType, PushdownStoreSymbolType > > > & getCallTransitions ( ) const;
const ext::map < ext::tuple < StateType, InputSymbolType, PushdownStoreSymbolType >, ext::set < StateType > > & getReturnTransitions ( ) const;
- const ext::map < std::pair < StateType, InputSymbolType >, ext::set < StateType > > & getLocalTransitions ( ) const;
+ const ext::map < ext::pair < StateType, InputSymbolType >, ext::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 );
@@ -319,10 +319,10 @@ public:
VisiblyPushdownNPDA < > * res = new VisiblyPushdownNPDA < > ( std::move ( states ), std::move ( call_alphabet ), std::move ( return_alphabet ), std::move ( local_alphabet ), std::move ( pushdownAlphabet ), std::move ( initialStates ), std::move ( bottomSymbol ), std::move ( finalStates ) );
- for ( std::pair < std::pair < StateType, InputSymbolType >, ext::set < std::pair < StateType, PushdownStoreSymbolType > > > && transition : ext::make_moveable_map ( callTransitions ) ) {
- ext::set < std::pair < DefaultStateType, DefaultSymbolType > > targets;
+ for ( std::pair < ext::pair < StateType, InputSymbolType >, ext::set < ext::pair < StateType, PushdownStoreSymbolType > > > && transition : ext::make_moveable_map ( callTransitions ) ) {
+ ext::set < ext::pair < DefaultStateType, DefaultSymbolType > > targets;
for ( std::pair < StateType, PushdownStoreSymbolType > && target : ext::make_moveable_set ( transition.second ) )
- targets.insert ( std::make_pair ( AutomatonNormalize::normalizeState ( std::move ( target.first ) ), alphabet::SymbolNormalize::normalizeSymbol ( std::move ( target.second ) ) ) );
+ targets.insert ( ext::make_pair ( AutomatonNormalize::normalizeState ( std::move ( target.first ) ), alphabet::SymbolNormalize::normalizeSymbol ( std::move ( target.second ) ) ) );
DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) );
DefaultSymbolType input = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( transition.first.second ) );
@@ -340,7 +340,7 @@ public:
res->addReturnTransitions ( std::move ( from ), std::move ( input ), std::move ( pop ), std::move ( to ) );
}
- for ( std::pair < std::pair < StateType, InputSymbolType >, ext::set < StateType > > && transition : ext::make_moveable_map ( localTransitions ) ) {
+ for ( std::pair < ext::pair < StateType, InputSymbolType >, ext::set < StateType > > && transition : ext::make_moveable_map ( localTransitions ) ) {
ext::set < DefaultStateType > to = AutomatonNormalize::normalizeStates ( std::move ( transition.second ) );
DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) );
@@ -389,8 +389,8 @@ bool VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >
throw AutomatonException("Pushdown store symbol \"" + ext::to_string ( push ) + "\" doesn't exist.");
}
- std::pair<StateType, InputSymbolType> key(std::move(from), std::move(input));
- std::pair<StateType, PushdownStoreSymbolType> value = std::make_pair(std::move(to), std::move(push));
+ ext::pair<StateType, InputSymbolType> key(std::move(from), std::move(input));
+ ext::pair<StateType, PushdownStoreSymbolType> value = ext::make_pair(std::move(to), std::move(push));
return callTransitions[std::move(key)].insert(std::move(value)).second;
}
@@ -432,13 +432,13 @@ bool VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >
throw AutomatonException("State \"" + ext::to_string ( to ) + "\" doesn't exist.");
}
- std::pair<StateType, InputSymbolType> key(std::move(from), std::move(input));
+ ext::pair<StateType, InputSymbolType> key(std::move(from), std::move(input));
return localTransitions[std::move(key)].insert(std::move(to)).second;
}
template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
-void VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::addCallTransitions(StateType from, InputSymbolType input, ext::set < std::pair < StateType, PushdownStoreSymbolType > > targets ) {
+void VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::addCallTransitions(StateType from, InputSymbolType input, ext::set < ext::pair < StateType, PushdownStoreSymbolType > > targets ) {
if ( ! getStates().count(from))
throw AutomatonException("State \"" + ext::to_string ( from ) + "\" doesn't exist.");
@@ -453,7 +453,7 @@ void VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >
throw AutomatonException("Pushdown store symbol \"" + ext::to_string ( target.second ) + "\" doesn't exist.");
}
- std::pair<StateType, InputSymbolType> key(std::move(from), std::move(input));
+ ext::pair<StateType, InputSymbolType> key(std::move(from), std::move(input));
callTransitions[std::move(key)].insert ( ext::make_moveable_set ( targets ).begin ( ), ext::make_moveable_set ( targets ).end ( ) );
}
@@ -486,14 +486,14 @@ void VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >
if ( !std::includes ( getStates ( ).begin ( ), getStates ( ).end ( ), to.begin ( ), to.end ( ) ) )
throw AutomatonException ( "Some target states don't exist." );
- std::pair<StateType, InputSymbolType> key(std::move(from), std::move(input));
+ ext::pair<StateType, InputSymbolType> key(std::move(from), std::move(input));
localTransitions[std::move(key)].insert ( ext::make_moveable_set ( to ).begin ( ), ext::make_moveable_set ( to ).end ( ) );
}
template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
bool VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::removeCallTransition(const StateType& from, const InputSymbolType& input, const StateType& to, const PushdownStoreSymbolType& push) {
- std::pair<StateType, InputSymbolType> key(from, input);
- std::pair<StateType, PushdownStoreSymbolType> value = std::make_pair(to, push);
+ ext::pair<StateType, InputSymbolType> key(from, input);
+ ext::pair<StateType, PushdownStoreSymbolType> value = ext::make_pair(to, push);
return callTransitions[key].erase(value);
}
@@ -507,13 +507,13 @@ bool VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >
template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
bool VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::removeLocalTransition(const StateType& from, const InputSymbolType& input, const StateType& to) {
- std::pair<StateType, InputSymbolType> key(from, input);
+ ext::pair<StateType, InputSymbolType> key(from, input);
return localTransitions[key].erase(to);
}
template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
-const ext::map<std::pair<StateType, InputSymbolType>, ext::set<std::pair<StateType, PushdownStoreSymbolType> > >& VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::getCallTransitions() const {
+const ext::map<ext::pair<StateType, InputSymbolType>, ext::set<ext::pair<StateType, PushdownStoreSymbolType> > >& VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::getCallTransitions() const {
return callTransitions;
}
@@ -523,7 +523,7 @@ const ext::map<ext::tuple<StateType, InputSymbolType, PushdownStoreSymbolType>,
}
template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
-const ext::map<std::pair<StateType, InputSymbolType>, ext::set<StateType> >& VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::getLocalTransitions() const {
+const ext::map<ext::pair<StateType, InputSymbolType>, ext::set<StateType> >& VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::getLocalTransitions() const {
return localTransitions;
}
@@ -690,7 +690,7 @@ template < class InputSymbolType, class PushdownStoreSymbolType, class StateType
class ComponentConstraint< automaton::VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >, InputSymbolType, automaton::CallAlphabet > {
public:
static bool used ( const automaton::VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & automaton, const InputSymbolType & symbol ) {
- for (const std::pair<const std::pair<StateType, InputSymbolType>, ext::set < std::pair<StateType, PushdownStoreSymbolType> > >& callTransition : automaton.getCallTransitions())
+ for ( const std::pair<const ext::pair<StateType, InputSymbolType>, ext::set < ext::pair<StateType, PushdownStoreSymbolType> > >& callTransition : automaton.getCallTransitions())
if (symbol == callTransition.first.second)
return true;
@@ -713,7 +713,7 @@ template < class InputSymbolType, class PushdownStoreSymbolType, class StateType
class ComponentConstraint< automaton::VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >, InputSymbolType, automaton::ReturnAlphabet > {
public:
static bool used ( const automaton::VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & automaton, const InputSymbolType & symbol ) {
- for (const std::pair<const ext::tuple<StateType, InputSymbolType, PushdownStoreSymbolType>, ext::set < StateType> >& returnTransition : automaton.getReturnTransitions())
+ for ( const std::pair<const ext::tuple<StateType, InputSymbolType, PushdownStoreSymbolType>, ext::set < StateType> >& returnTransition : automaton.getReturnTransitions())
if (symbol == std::get<1>(returnTransition.first))
return true;
@@ -736,7 +736,7 @@ template < class InputSymbolType, class PushdownStoreSymbolType, class StateType
class ComponentConstraint< automaton::VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >, InputSymbolType, automaton::LocalAlphabet > {
public:
static bool used ( const automaton::VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & automaton, const InputSymbolType & symbol ) {
- for (const std::pair<const std::pair<StateType, InputSymbolType>, ext::set < StateType >>& localTransition : automaton.getLocalTransitions())
+ for ( const std::pair<const ext::pair<StateType, InputSymbolType>, ext::set < StateType >>& localTransition : automaton.getLocalTransitions())
if (symbol == localTransition.first.second)
return true;
@@ -759,12 +759,12 @@ template < class InputSymbolType, class PushdownStoreSymbolType, class StateType
class ComponentConstraint< automaton::VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >, PushdownStoreSymbolType, automaton::PushdownStoreAlphabet > {
public:
static bool used ( const automaton::VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & automaton, const PushdownStoreSymbolType & symbol ) {
- for (const std::pair<const std::pair<StateType, InputSymbolType>, ext::set<std::pair<StateType, PushdownStoreSymbolType> > >& callTransition : automaton.getCallTransitions())
- for(const std::pair<StateType, PushdownStoreSymbolType>& to : callTransition.second)
+ for ( const std::pair<const ext::pair<StateType, InputSymbolType>, ext::set<ext::pair<StateType, PushdownStoreSymbolType> > >& callTransition : automaton.getCallTransitions())
+ for(const ext::pair<StateType, PushdownStoreSymbolType>& to : callTransition.second)
if (symbol == to.second)
return true;
- for (const std::pair<const ext::tuple<StateType, InputSymbolType, PushdownStoreSymbolType>, ext::set<StateType> >& returnTransition : automaton.getReturnTransitions())
+ for ( const std::pair<const ext::tuple<StateType, InputSymbolType, PushdownStoreSymbolType>, ext::set<StateType> >& returnTransition : automaton.getReturnTransitions())
if (symbol == std::get<2>(returnTransition.first))
return true;
@@ -803,16 +803,16 @@ public:
if ( automaton.getFinalStates ( ).count ( state ) )
return true;
- for (const std::pair<const std::pair<StateType, InputSymbolType>, ext::set<std::pair<StateType, PushdownStoreSymbolType> > >& callTransition : automaton.getCallTransitions()) {
+ for ( const std::pair<const ext::pair<StateType, InputSymbolType>, ext::set<ext::pair<StateType, PushdownStoreSymbolType> > >& callTransition : automaton.getCallTransitions()) {
if (state == callTransition.first.first)
return true;
- for(const std::pair<StateType, PushdownStoreSymbolType>& target : callTransition.second) {
+ for(const ext::pair<StateType, PushdownStoreSymbolType>& target : callTransition.second) {
if(target.first == state)
return true;
}
}
- for (const std::pair<const ext::tuple<StateType, InputSymbolType, PushdownStoreSymbolType>, ext::set<StateType> >& returnTransition : automaton.getReturnTransitions()) {
+ for ( const std::pair<const ext::tuple<StateType, InputSymbolType, PushdownStoreSymbolType>, ext::set<StateType> >& returnTransition : automaton.getReturnTransitions()) {
if (state == std::get<0>(returnTransition.first))
return true;
for(const StateType& target : returnTransition.second) {
@@ -821,7 +821,7 @@ public:
}
}
- for (const std::pair<const std::pair<StateType, InputSymbolType>, ext::set<StateType> >& localTransition : automaton.getLocalTransitions()) {
+ for ( const std::pair<const ext::pair<StateType, InputSymbolType>, ext::set<StateType> >& localTransition : automaton.getLocalTransitions()) {
if (state == localTransition.first.first)
return true;
for(const StateType& target : localTransition.second) {
diff --git a/alib2data/src/automaton/TA/DFTA.h b/alib2data/src/automaton/TA/DFTA.h
index 520661544c71a5eed48780bb11b17c7167763fd7..a3e4e942dd86ada76eebbb6715a675d12e61563d 100644
--- a/alib2data/src/automaton/TA/DFTA.h
+++ b/alib2data/src/automaton/TA/DFTA.h
@@ -38,7 +38,7 @@ class FinalStates;
*/
template<class SymbolType, class RankType, class StateType >
class DFTA final : public AutomatonBase, public alib::Components < DFTA < SymbolType, RankType, StateType >, common::ranked_symbol < SymbolType, RankType >, ext::tuple < InputAlphabet >, ext::tuple < >, StateType, ext::tuple < States, FinalStates >, ext::tuple < > > {
- ext::map < std::pair < common::ranked_symbol < SymbolType, RankType >, ext::vector < StateType > >, StateType > transitions;
+ ext::map < ext::pair < common::ranked_symbol < SymbolType, RankType >, ext::vector < StateType > >, StateType > transitions;
public:
explicit DFTA ( );
@@ -118,7 +118,7 @@ public:
/**
* @return automaton transitions
*/
- const ext::map < std::pair < common::ranked_symbol < SymbolType, RankType >, ext::vector < StateType > >, StateType > & getTransitions ( ) const { return transitions; }
+ const ext::map < ext::pair < common::ranked_symbol < SymbolType, RankType >, ext::vector < StateType > >, StateType > & getTransitions ( ) const { return transitions; }
ext::set < StateType > getTransitionRightSide ( const common::ranked_symbol < SymbolType, RankType > symbol, const ext::vector < StateType > & states );
@@ -162,7 +162,7 @@ public:
DFTA < > * res = new DFTA < > ( std::move ( states ), std::move ( alphabet ), std::move ( finalStates ) );
- for ( std::pair < std::pair < common::ranked_symbol < SymbolType, RankType >, ext::vector < StateType > >, StateType > && transition : ext::make_moveable_map ( transitions ) ) {
+ for ( std::pair < ext::pair < common::ranked_symbol < SymbolType, RankType >, ext::vector < StateType > >, StateType > && transition : ext::make_moveable_map ( transitions ) ) {
common::ranked_symbol < DefaultSymbolType, DefaultRankType > input = alphabet::SymbolNormalize::normalizeRankedSymbol ( std::move ( transition.first.first ) );
ext::vector < DefaultStateType > from = AutomatonNormalize::normalizeStates ( std::move ( transition.first.second ) );
DefaultStateType to = AutomatonNormalize::normalizeState ( std::move ( transition.second ) );
@@ -212,7 +212,7 @@ bool DFTA < SymbolType, RankType, StateType >::addTransition ( common::ranked_sy
throw AutomatonException("State \"" + ext::to_string ( it ) + "\" doesn't exist.");
}
- std::pair<common::ranked_symbol < SymbolType, RankType >, ext::vector<StateType> > key = std::make_pair ( std::move ( symbol ), std::move ( prevStates ) );
+ ext::pair<common::ranked_symbol < SymbolType, RankType >, ext::vector<StateType> > key = ext::make_pair ( std::move ( symbol ), std::move ( prevStates ) );
if ( transitions.find ( key ) != transitions.end ( ) ) {
if ( transitions.find ( key )->second == next )
return false;
@@ -226,7 +226,7 @@ bool DFTA < SymbolType, RankType, StateType >::addTransition ( common::ranked_sy
template<class SymbolType, class RankType, class StateType >
bool DFTA < SymbolType, RankType, StateType >::removeTransition(const common::ranked_symbol < SymbolType, RankType > symbol, const ext::vector<StateType> & states, const StateType & next) {
- std::pair<common::ranked_symbol < SymbolType, RankType >, ext::vector<StateType> > key = std::make_pair(symbol, states);
+ ext::pair<common::ranked_symbol < SymbolType, RankType >, ext::vector<StateType> > key = ext::make_pair(symbol, states);
if ( transitions.find ( key ) == transitions.end ( ) )
return false;
@@ -335,7 +335,7 @@ template<class SymbolType, class RankType, class StateType >
class ComponentConstraint< automaton::DFTA < SymbolType, RankType, StateType >, common::ranked_symbol < SymbolType, RankType >, automaton::InputAlphabet > {
public:
static bool used ( const automaton::DFTA < SymbolType, RankType, StateType > & automaton, const common::ranked_symbol < SymbolType, RankType > & symbol ) {
- for (const std::pair<const std::pair<common::ranked_symbol < SymbolType, RankType >, ext::vector<StateType> >, StateType>& t : automaton.getTransitions())
+ for ( const std::pair<const ext::pair<common::ranked_symbol < SymbolType, RankType >, ext::vector<StateType> >, StateType>& t : automaton.getTransitions())
if (t.first.first == symbol)
return true;
@@ -357,7 +357,7 @@ public:
if ( automaton.getFinalStates ( ).count ( state ) )
return true;
- for (const std::pair<const std::pair<common::ranked_symbol < SymbolType, RankType >, ext::vector<StateType> >, StateType>& t : automaton.getTransitions())
+ for ( const std::pair<const ext::pair<common::ranked_symbol < SymbolType, RankType >, ext::vector<StateType> >, StateType>& t : automaton.getTransitions())
if(ext::contains(t.first.second.begin(), t.first.second.end(), state ) || t.second == state)
return true;
diff --git a/alib2data/src/automaton/TA/NFTA.h b/alib2data/src/automaton/TA/NFTA.h
index 0dc15de9e2dae68f540a8be47fd30141615279c9..2871a7b85bb0a8cc57a39bafd9d571eb211dbbf9 100644
--- a/alib2data/src/automaton/TA/NFTA.h
+++ b/alib2data/src/automaton/TA/NFTA.h
@@ -37,7 +37,7 @@ class FinalStates;
*/
template < class SymbolType, class RankType, class StateType >
class NFTA final : public AutomatonBase, public alib::Components < NFTA < SymbolType, RankType, StateType >, common::ranked_symbol < SymbolType, RankType >, ext::tuple < InputAlphabet >, ext::tuple < >, StateType, ext::tuple < States, FinalStates >, ext::tuple < > > {
- ext::map < std::pair < common::ranked_symbol < SymbolType, RankType >, ext::vector < StateType > >, ext::set < StateType > > transitions;
+ ext::map < ext::pair < common::ranked_symbol < SymbolType, RankType >, ext::vector < StateType > >, ext::set < StateType > > transitions;
public:
explicit NFTA ( );
@@ -127,7 +127,7 @@ public:
/**
* @return automaton transitions
*/
- const ext::map < std::pair < common::ranked_symbol < SymbolType, RankType >, ext::vector < StateType > >, ext::set < StateType > > & getTransitions ( ) const { return transitions; }
+ const ext::map < ext::pair < common::ranked_symbol < SymbolType, RankType >, ext::vector < StateType > >, ext::set < StateType > > & getTransitions ( ) const { return transitions; }
ext::set < StateType > getTransitionRightSide ( const common::ranked_symbol < SymbolType, RankType > symbol, const ext::vector < StateType > & states );
@@ -180,7 +180,7 @@ public:
NFTA < > * res = new NFTA < > ( std::move ( states ), std::move ( alphabet ), std::move ( finalStates ) );
- for ( std::pair < std::pair < common::ranked_symbol < SymbolType, RankType >, ext::vector < StateType > >, ext::set < StateType > > && transition : ext::make_moveable_map ( transitions ) ) {
+ for ( std::pair < ext::pair < common::ranked_symbol < SymbolType, RankType >, ext::vector < StateType > >, ext::set < StateType > > && transition : ext::make_moveable_map ( transitions ) ) {
common::ranked_symbol < DefaultSymbolType, DefaultRankType > input = alphabet::SymbolNormalize::normalizeRankedSymbol ( std::move ( transition.first.first ) );
ext::vector < DefaultStateType > from = AutomatonNormalize::normalizeStates ( std::move ( transition.first.second ) );
ext::set < DefaultStateType > to = AutomatonNormalize::normalizeStates ( std::move ( transition.second ) );
@@ -239,7 +239,7 @@ bool NFTA < SymbolType, RankType, StateType >::addTransition ( common::ranked_sy
throw AutomatonException("State \"" + ext::to_string ( it ) + "\" doesn't exist.");
}
- std::pair<common::ranked_symbol < SymbolType, RankType >, ext::vector < StateType > > key = std::make_pair ( std::move ( symbol ), std::move ( prevStates ) );
+ ext::pair<common::ranked_symbol < SymbolType, RankType >, ext::vector < StateType > > key = ext::make_pair ( std::move ( symbol ), std::move ( prevStates ) );
return transitions [ std::move ( key ) ].insert ( std::move ( next ) ).second;
}
@@ -259,19 +259,19 @@ void NFTA < SymbolType, RankType, StateType >::addTransitions ( common::ranked_s
throw AutomatonException("State \"" + ext::to_string ( it ) + "\" doesn't exist.");
}
- std::pair<common::ranked_symbol < SymbolType, RankType >, ext::vector < StateType > > key = std::make_pair ( std::move ( symbol ), std::move ( prevStates ) );
+ ext::pair<common::ranked_symbol < SymbolType, RankType >, ext::vector < StateType > > key = ext::make_pair ( std::move ( symbol ), std::move ( prevStates ) );
transitions [ std::move ( key ) ].insert ( ext::make_moveable_set ( next ).begin ( ), ext::make_moveable_set ( next ).end ( ) );
}
template < class SymbolType, class RankType, class StateType >
bool NFTA < SymbolType, RankType, StateType >::removeTransition(const common::ranked_symbol < SymbolType, RankType > symbol, const ext::vector<StateType> & states, const StateType & next) {
- std::pair<common::ranked_symbol < SymbolType, RankType >, ext::vector<StateType> > key = std::make_pair(symbol, states);
+ ext::pair<common::ranked_symbol < SymbolType, RankType >, ext::vector<StateType> > key = ext::make_pair(symbol, states);
return transitions[key].erase(next);
}
template < class SymbolType, class RankType, class StateType >
bool NFTA < SymbolType, RankType, StateType >::isDeterministic() const {
- for (const std::pair<const std::pair<common::ranked_symbol < SymbolType, RankType >, ext::vector<StateType> >, ext::set<StateType> >& t : transitions)
+ for ( const std::pair<const ext::pair<common::ranked_symbol < SymbolType, RankType >, ext::vector<StateType> >, ext::set<StateType> >& t : transitions)
if (t . second.size() != 1 || t . second.size() != 0)
return false;
@@ -387,7 +387,7 @@ template < class SymbolType, class RankType, class StateType >
class ComponentConstraint< automaton::NFTA < SymbolType, RankType, StateType >, common::ranked_symbol < SymbolType, RankType >, automaton::InputAlphabet > {
public:
static bool used ( const automaton::NFTA < SymbolType, RankType, StateType > & automaton, const common::ranked_symbol < SymbolType, RankType > & symbol ) {
- for (const std::pair<const std::pair<common::ranked_symbol < SymbolType, RankType >, ext::vector<StateType> >, ext::set<StateType>>& t : automaton.getTransitions())
+ for ( const std::pair<const ext::pair<common::ranked_symbol < SymbolType, RankType >, ext::vector<StateType> >, ext::set<StateType>>& t : automaton.getTransitions())
if (t.first.first == symbol)
return true;
@@ -409,7 +409,7 @@ public:
if ( automaton.getFinalStates ( ).count ( state ) )
return true;
- for (const std::pair<const std::pair<common::ranked_symbol < SymbolType, RankType >, ext::vector<StateType> >, ext::set<StateType>>& t : automaton.getTransitions())
+ for ( const std::pair<const ext::pair<common::ranked_symbol < SymbolType, RankType >, ext::vector<StateType> >, ext::set<StateType>>& t : automaton.getTransitions())
if(ext::contains(t.first.second.begin(), t.first.second.end(), state ) || t . second.count ( state ) )
return true;
diff --git a/alib2data/src/automaton/TM/OneTapeDTM.h b/alib2data/src/automaton/TM/OneTapeDTM.h
index 2df1df67f31a0d96f0a7d2cfce471b71e9d0d34f..2c6e269ae37ca342f45f1dab5185d6c5b7a94af8 100644
--- a/alib2data/src/automaton/TM/OneTapeDTM.h
+++ b/alib2data/src/automaton/TM/OneTapeDTM.h
@@ -42,7 +42,7 @@ class InitialState;
template<class SymbolType, class StateType >
class OneTapeDTM final : public AutomatonBase, public alib::Components < OneTapeDTM < SymbolType, StateType >, SymbolType, ext::tuple < TapeAlphabet, InputAlphabet >, ext::tuple < BlankSymbol >, StateType, ext::tuple < States, FinalStates >, ext::tuple < InitialState > > {
protected:
- ext::map < std::pair < StateType, SymbolType >, ext::tuple < StateType, SymbolType, Shift > > transitions;
+ ext::map < ext::pair < StateType, SymbolType >, ext::tuple < StateType, SymbolType, Shift > > transitions;
public:
explicit OneTapeDTM ( ext::set < StateType > states, ext::set < SymbolType > tapeAlphabet, SymbolType blankSymbol, ext::set< SymbolType > inputAlphabet, StateType initialState, ext::set < StateType > finalStates );
@@ -159,7 +159,7 @@ public:
/**
* @return TM transitions
*/
- const ext::map < std::pair < StateType, SymbolType >, ext::tuple < StateType, SymbolType, Shift > > & getTransitions ( ) const;
+ const ext::map < ext::pair < StateType, SymbolType >, ext::tuple < StateType, SymbolType, Shift > > & 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 );
@@ -202,7 +202,7 @@ public:
OneTapeDTM < > * res = new OneTapeDTM < > ( std::move ( states ), std::move ( tapeAlphabet ), std::move ( blankSymbol ), std::move ( alphabet ), std::move ( initialState ), std::move ( finalStates ) );
- for ( std::pair < std::pair < DefaultStateType, DefaultSymbolType >, ext::tuple < DefaultStateType, DefaultSymbolType, Shift > > && transition : ext::make_moveable_map ( transitions ) ) {
+ for ( std::pair < ext::pair < DefaultStateType, DefaultSymbolType >, ext::tuple < DefaultStateType, DefaultSymbolType, Shift > > && transition : ext::make_moveable_map ( transitions ) ) {
DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) );
DefaultSymbolType input = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( transition.first.second ) );
DefaultStateType to = AutomatonNormalize::normalizeState ( std::move ( std::get < 0 > ( transition.second ) ) );
@@ -253,7 +253,7 @@ bool OneTapeDTM<SymbolType, StateType>::addTransition(StateType from, SymbolType
throw AutomatonException("Tape symbol \"" + ext::to_string ( output ) + "\" doesn't exist.");
}
- std::pair<StateType, SymbolType> key = std::make_pair(std::move(from), std::move(input));
+ ext::pair<StateType, SymbolType> key = ext::make_pair(std::move(from), std::move(input));
ext::tuple<StateType, SymbolType, Shift > value(std::move(to), std::move(output), shift);
@@ -270,7 +270,7 @@ bool OneTapeDTM<SymbolType, StateType>::addTransition(StateType from, SymbolType
template<class SymbolType, class StateType >
bool OneTapeDTM<SymbolType, StateType>::removeTransition(const StateType& from, const SymbolType& input, const StateType& to, const SymbolType& output, const Shift& shift) {
- std::pair<StateType, SymbolType> key = std::make_pair(from, input);
+ ext::pair<StateType, SymbolType> key = ext::make_pair(from, input);
if (transitions.find(key) == transitions.end())
return false;
@@ -284,7 +284,7 @@ bool OneTapeDTM<SymbolType, StateType>::removeTransition(const StateType& from,
}
template<class SymbolType, class StateType >
-const ext::map<std::pair<StateType, SymbolType>, ext::tuple<StateType, SymbolType, Shift> >& OneTapeDTM<SymbolType, StateType>::getTransitions() const {
+const ext::map<ext::pair<StateType, SymbolType>, ext::tuple<StateType, SymbolType, Shift> >& OneTapeDTM<SymbolType, StateType>::getTransitions() const {
return transitions;
}
@@ -405,7 +405,7 @@ public:
if ( automaton.getInputAlphabet().count(symbol))
return true;
- for (const std::pair<const std::pair<StateType, SymbolType>, ext::tuple<StateType, SymbolType, automaton::Shift> >& transition : automaton.getTransitions())
+ for ( const std::pair<const ext::pair<StateType, SymbolType>, ext::tuple<StateType, SymbolType, automaton::Shift> >& transition : automaton.getTransitions())
if (symbol == transition.first.second || symbol == std::get<1>(transition.second))
return true;
@@ -461,7 +461,7 @@ public:
if ( automaton.getFinalStates ( ).count ( state ) )
return true;
- for (const std::pair<const std::pair<StateType, SymbolType>, ext::tuple<StateType, SymbolType, automaton::Shift> >& transition : automaton.getTransitions ( ) )
+ for ( const std::pair<const ext::pair<StateType, SymbolType>, ext::tuple<StateType, SymbolType, automaton::Shift> >& transition : automaton.getTransitions ( ) )
if ( state == transition.first.first || state == std::get < 0 > ( transition.second ) )
return true;
diff --git a/alib2data/src/automaton/common/AutomatonFromXMLParser.h b/alib2data/src/automaton/common/AutomatonFromXMLParser.h
index c30714c8f17b4760a78e384cdac142f4d97e984d..147b0aa736d4a9fbe7beeae826920d6d7e30765c 100644
--- a/alib2data/src/automaton/common/AutomatonFromXMLParser.h
+++ b/alib2data/src/automaton/common/AutomatonFromXMLParser.h
@@ -64,7 +64,7 @@ public:
template < class SymbolType >
static SymbolType parseBottomOfTheStackSymbol(ext::deque<sax::Token>::iterator& input);
template < class InputSymbolType, class PushdownStoreSymbolType >
- static ext::map<InputSymbolType, std::pair<ext::vector<PushdownStoreSymbolType>, ext::vector<PushdownStoreSymbolType> > > parseInputToPushdownStoreOperation(ext::deque<sax::Token>::iterator& input);
+ static ext::map<InputSymbolType, ext::pair<ext::vector<PushdownStoreSymbolType>, ext::vector<PushdownStoreSymbolType> > > parseInputToPushdownStoreOperation(ext::deque<sax::Token>::iterator& input);
template < class StateType >
static StateType parseTransitionFrom(ext::deque<sax::Token>::iterator& input);
@@ -309,8 +309,8 @@ SymbolType AutomatonFromXMLParser::parseBottomOfTheStackSymbol ( ext::deque < sa
}
template < class InputSymbolType, class PushdownStoreSymbolType >
-ext::map < InputSymbolType, std::pair < ext::vector < PushdownStoreSymbolType >, ext::vector < PushdownStoreSymbolType > > > AutomatonFromXMLParser::parseInputToPushdownStoreOperation ( ext::deque < sax::Token >::iterator & input ) {
- ext::map < InputSymbolType, std::pair < ext::vector < PushdownStoreSymbolType >, ext::vector < PushdownStoreSymbolType > > > operations;
+ext::map < InputSymbolType, ext::pair < ext::vector < PushdownStoreSymbolType >, ext::vector < PushdownStoreSymbolType > > > AutomatonFromXMLParser::parseInputToPushdownStoreOperation ( ext::deque < sax::Token >::iterator & input ) {
+ ext::map < InputSymbolType, ext::pair < ext::vector < PushdownStoreSymbolType >, ext::vector < PushdownStoreSymbolType > > > operations;
sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, "inputToPushdownStoreOperations" );
@@ -322,7 +322,7 @@ ext::map < InputSymbolType, std::pair < ext::vector < PushdownStoreSymbolType >,
ext::vector < PushdownStoreSymbolType > pop = parseTransitionPop < PushdownStoreSymbolType > ( input );
ext::vector < PushdownStoreSymbolType > push = parseTransitionPush < PushdownStoreSymbolType > ( input );
- operations.insert ( std::make_pair ( std::move ( inputSymbol ), std::make_pair ( std::move ( pop ), std::move ( push ) ) ) );
+ operations.insert ( std::make_pair ( std::move ( inputSymbol ), ext::make_pair ( std::move ( pop ), std::move ( push ) ) ) );
sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, "operation" );
}
diff --git a/alib2data/src/automaton/common/AutomatonToXMLComposer.h b/alib2data/src/automaton/common/AutomatonToXMLComposer.h
index db3731cea76b6380430c13d94065d23d95be6b7e..32c07bd46179092fb72e9f70dbaa8c2cbc063bb6 100644
--- a/alib2data/src/automaton/common/AutomatonToXMLComposer.h
+++ b/alib2data/src/automaton/common/AutomatonToXMLComposer.h
@@ -61,7 +61,7 @@ public:
template<class SymbolType>
static void composeBottomOfTheStackSymbol(ext::deque<sax::Token>&, const SymbolType& symbol);
template<class InputSymbolType, class PushdownStoreSymbolType >
- static void composeInputToPushdownStoreOperation(ext::deque<sax::Token>&, const ext::map<InputSymbolType, std::pair<ext::vector<PushdownStoreSymbolType>, ext::vector<PushdownStoreSymbolType> > >& operations);
+ static void composeInputToPushdownStoreOperation(ext::deque<sax::Token>&, const ext::map<InputSymbolType, ext::pair<ext::vector<PushdownStoreSymbolType>, ext::vector<PushdownStoreSymbolType> > >& operations);
template<class StateType>
static void composeTransitionTo(ext::deque<sax::Token>&, const StateType& state);
@@ -238,7 +238,7 @@ void AutomatonToXMLComposer::composeBottomOfTheStackSymbol(ext::deque<sax::Token
}
template < class InputSymbolType, class PushdownStoreSymbolType >
-void AutomatonToXMLComposer::composeInputToPushdownStoreOperation(ext::deque<sax::Token>& out, const ext::map<InputSymbolType, std::pair<ext::vector<PushdownStoreSymbolType>, ext::vector<PushdownStoreSymbolType> > >& operations) {
+void AutomatonToXMLComposer::composeInputToPushdownStoreOperation(ext::deque<sax::Token>& out, const ext::map<InputSymbolType, ext::pair<ext::vector<PushdownStoreSymbolType>, ext::vector<PushdownStoreSymbolType> > >& operations) {
out.emplace_back("inputToPushdownStoreOperations", sax::Token::TokenType::START_ELEMENT);
for(const auto& pushdownStoreOperation : operations) {
out.emplace_back("operation", sax::Token::TokenType::START_ELEMENT);
diff --git a/alib2data/src/grammar/ContextFree/CNF.h b/alib2data/src/grammar/ContextFree/CNF.h
index fd7f45eea7f61b39dad371075056393a7db20b76..c6ecb8320d3110a87b95d99e380815b8275b0d91 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, ext::tuple < TerminalAlphabet, NonterminalAlphabet >, ext::tuple < InitialSymbol > > {
- ext::map < SymbolType, ext::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > rules;
+ ext::map < SymbolType, ext::set < ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > > > rules;
bool generatesEpsilon;
public:
@@ -49,17 +49,17 @@ public:
virtual GrammarBase * plunder ( ) &&;
- bool addRule ( SymbolType leftHandSide, ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rightHandSide );
+ bool addRule ( SymbolType leftHandSide, ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > rightHandSide );
bool addRule ( SymbolType leftHandSide, SymbolType rightHandSide );
- bool addRule ( SymbolType leftHandSide, std::pair < SymbolType, SymbolType > rightHandSide );
+ bool addRule ( SymbolType leftHandSide, ext::pair < SymbolType, SymbolType > rightHandSide );
- void addRules ( SymbolType leftHandSide, ext::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > rightHandSide );
+ void addRules ( SymbolType leftHandSide, ext::set < ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > > rightHandSide );
- const ext::map < SymbolType, ext::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & getRules ( ) const;
+ const ext::map < SymbolType, ext::set < ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > > > & getRules ( ) const;
- bool removeRule ( const SymbolType & leftHandSide, const ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rightHandSide );
+ bool removeRule ( const SymbolType & leftHandSide, const ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > & rightHandSide );
bool removeRule ( const SymbolType & leftHandSide, const SymbolType & rightHandSide );
- bool removeRule ( const SymbolType & leftHandSide, const std::pair < SymbolType, SymbolType > & rightHandSide );
+ bool removeRule ( const SymbolType & leftHandSide, const ext::pair < SymbolType, SymbolType > & rightHandSide );
bool addRawRule ( SymbolType leftHandSide, ext::vector < SymbolType > rightHandSide );
@@ -140,10 +140,10 @@ public:
CNF < > * res = new CNF < > ( std::move ( nonterminals ), std::move ( terminals ), std::move ( initialSymbol ) );
- for ( std::pair < SymbolType, ext::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > && rule : ext::make_moveable_map ( rules ) ) {
+ for ( std::pair < SymbolType, ext::set < ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > > > && rule : ext::make_moveable_map ( rules ) ) {
- ext::set < ext::variant < DefaultSymbolType, std::pair < DefaultSymbolType, DefaultSymbolType > > > rhs;
- for ( ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > && target : ext::make_moveable_set ( rule.second ) )
+ ext::set < ext::variant < DefaultSymbolType, ext::pair < DefaultSymbolType, DefaultSymbolType > > > rhs;
+ for ( ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > && target : ext::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, ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rightHandSide ) {
+bool CNF < SymbolType >::addRule ( SymbolType leftHandSide, ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > rightHandSide ) {
if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
throw GrammarException ( "Rule must rewrite nonterminal symbol" );
@@ -184,7 +184,7 @@ bool CNF < SymbolType >::addRule ( SymbolType leftHandSide, ext::variant < Symbo
if ( !getTerminalAlphabet ( ).count ( rightHandSide.template get < SymbolType > ( ) ) )
throw GrammarException ( "Rule must rewrite to terminal symbol" );
} else {
- const std::pair < SymbolType, SymbolType > rhs = rightHandSide.template get < std::pair < SymbolType, SymbolType > > ( );
+ const ext::pair < SymbolType, SymbolType > rhs = rightHandSide.template get < ext::pair < SymbolType, SymbolType > > ( );
if ( !getNonterminalAlphabet ( ).count ( rhs.first ) )
throw GrammarException ( "Symbol \"" + ext::to_string ( rhs.first ) + "\" is not a nonterminal symbol" );
@@ -198,29 +198,29 @@ bool CNF < SymbolType >::addRule ( SymbolType leftHandSide, ext::variant < Symbo
template < class SymbolType >
bool CNF < SymbolType >::addRule ( SymbolType leftHandSide, SymbolType rightHandSide ) {
- ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( std::move ( rightHandSide ) );
+ ext::variant < SymbolType, ext::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 ) {
- ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( std::move ( rightHandSide ) );
+bool CNF < SymbolType >::addRule ( SymbolType leftHandSide, ext::pair < SymbolType, SymbolType > rightHandSide ) {
+ ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > rhs ( std::move ( rightHandSide ) );
return addRule ( std::move ( leftHandSide ), std::move ( rhs ) );
}
template < class SymbolType >
-void CNF < SymbolType >::addRules ( SymbolType leftHandSide, ext::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > rightHandSide ) {
+void CNF < SymbolType >::addRules ( SymbolType leftHandSide, ext::set < ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > > rightHandSide ) {
if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
throw GrammarException ( "Rule must rewrite nonterminal symbol" );
- for ( const ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > & element : rightHandSide ) {
+ for ( const ext::variant < SymbolType, ext::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" );
} else {
- const std::pair < SymbolType, SymbolType > rhs = element.template get < std::pair < SymbolType, SymbolType > > ( );
+ const ext::pair < SymbolType, SymbolType > rhs = element.template get < ext::pair < SymbolType, SymbolType > > ( );
if ( !getNonterminalAlphabet ( ).count ( rhs.first ) )
throw GrammarException ( "Symbol \"" + ext::to_string ( rhs.first ) + "\" is not a nonterminal symbol" );
@@ -234,25 +234,25 @@ void CNF < SymbolType >::addRules ( SymbolType leftHandSide, ext::set < ext::var
}
template < class SymbolType >
-const ext::map < SymbolType, ext::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & CNF < SymbolType >::getRules ( ) const {
+const ext::map < SymbolType, ext::set < ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > > > & CNF < SymbolType >::getRules ( ) const {
return rules;
}
template < class SymbolType >
-bool CNF < SymbolType >::removeRule ( const SymbolType & leftHandSide, const ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rightHandSide ) {
+bool CNF < SymbolType >::removeRule ( const SymbolType & leftHandSide, const ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > & rightHandSide ) {
return rules[leftHandSide].erase ( rightHandSide );
}
template < class SymbolType >
bool CNF < SymbolType >::removeRule ( const SymbolType & leftHandSide, const SymbolType & rightHandSide ) {
- ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( rightHandSide );
+ ext::variant < SymbolType, ext::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 ) {
- ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( rightHandSide );
+bool CNF < SymbolType >::removeRule ( const SymbolType & leftHandSide, const ext::pair < SymbolType, SymbolType > & rightHandSide ) {
+ ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > rhs ( rightHandSide );
return removeRule ( leftHandSide, rhs );
}
@@ -268,7 +268,7 @@ bool CNF < SymbolType >::addRawRule ( SymbolType leftHandSide, ext::vector < Sym
} else if ( rightHandSide.size ( ) == 1 ) {
return addRule ( std::move ( leftHandSide ), std::move ( rightHandSide[0] ) );
} else if ( rightHandSide.size ( ) == 2 ) {
- return addRule ( std::move ( leftHandSide ), std::make_pair ( std::move ( rightHandSide[0] ), std::move ( rightHandSide[1] ) ) );
+ return addRule ( std::move ( leftHandSide ), ext::make_pair ( std::move ( rightHandSide[0] ), std::move ( rightHandSide[1] ) ) );
} else {
throw GrammarException ( "Invalid right hand side" );
}
@@ -284,7 +284,7 @@ ext::map < SymbolType, ext::set < ext::vector < SymbolType > > > CNF < SymbolTyp
ext::vector < SymbolType > tmp { rhs.template get < SymbolType > ( ) };
res[rule.first].insert ( std::move ( tmp ) );
} else {
- const auto & realRHS = rhs.template get < std::pair < SymbolType, SymbolType > > ( );
+ const auto & realRHS = rhs.template get < ext::pair < SymbolType, SymbolType > > ( );
ext::vector < SymbolType > tmp { realRHS.first, realRHS.second };
res[rule.first].insert ( std::move ( tmp ) );
}
@@ -307,7 +307,7 @@ bool CNF < SymbolType >::removeRawRule ( const SymbolType & leftHandSide, const
} else if ( rightHandSide.size ( ) == 1 ) {
return removeRule ( leftHandSide, rightHandSide[0] );
} else if ( rightHandSide.size ( ) == 2 ) {
- return removeRule ( leftHandSide, std::make_pair ( rightHandSide[0], rightHandSide[1] ) );
+ return removeRule ( leftHandSide, ext::make_pair ( rightHandSide[0], rightHandSide[1] ) );
} else {
throw GrammarException ( "Invalid right hand side" );
}
@@ -375,7 +375,7 @@ CNF < SymbolType > CNF < SymbolType >::parse ( ext::deque < sax::Token >::iterat
template < class SymbolType >
void CNF < SymbolType >::parseRule ( ext::deque < sax::Token >::iterator & input, CNF & grammar ) {
SymbolType lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS < SymbolType > ( input );
- ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs = GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS < SymbolType > ( input );
+ ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > rhs = GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS < SymbolType > ( input );
grammar.addRule ( std::move ( lhs ), std::move ( rhs ) );
}
@@ -424,9 +424,9 @@ 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, ext::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 ) )
+ for ( const std::pair < const SymbolType, ext::set < ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > > > & rule : grammar.getRules ( ) )
+ for ( const ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > & rhs : rule.second )
+ if ( ( rhs.template is < SymbolType > ( ) && ( rhs.template get < SymbolType > ( ) == symbol ) ) || ( rhs.template get < ext::pair < SymbolType, SymbolType > > ( ).first == symbol ) )
return true;
return false;
@@ -446,12 +446,12 @@ 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, ext::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & rule : grammar.getRules ( ) ) {
+ for ( const std::pair < const SymbolType, ext::set < ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > > > & rule : grammar.getRules ( ) ) {
if ( rule.first == symbol )
return true;
- for ( const ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rhs : rule.second )
- if ( rhs.template get < std::pair < SymbolType, SymbolType > > ( ).second == symbol )
+ for ( const ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > & rhs : rule.second )
+ if ( rhs.template get < ext::pair < SymbolType, SymbolType > > ( ).second == symbol )
return true;
}
diff --git a/alib2data/src/grammar/ContextFree/GNF.h b/alib2data/src/grammar/ContextFree/GNF.h
index dad70aa9c9dcc70516b15158de9acf2e8d525a4c..acde0fed8db5d1a289ffe1ce8c25557bd7145e15 100644
--- a/alib2data/src/grammar/ContextFree/GNF.h
+++ b/alib2data/src/grammar/ContextFree/GNF.h
@@ -36,7 +36,7 @@ class InitialSymbol;
template < class SymbolType >
class GNF final : public GrammarBase, public alib::Components < GNF < SymbolType >, SymbolType, ext::tuple < TerminalAlphabet, NonterminalAlphabet >, ext::tuple < InitialSymbol > > {
- ext::map < SymbolType, ext::set < std::pair < SymbolType, ext::vector < SymbolType > > > > rules;
+ ext::map < SymbolType, ext::set < ext::pair < SymbolType, ext::vector < SymbolType > > > > rules;
bool generatesEpsilon;
public:
@@ -48,13 +48,13 @@ public:
virtual GrammarBase * plunder ( ) &&;
- bool addRule ( SymbolType leftHandSide, std::pair < SymbolType, ext::vector < SymbolType > > rightHandSide );
+ bool addRule ( SymbolType leftHandSide, ext::pair < SymbolType, ext::vector < SymbolType > > rightHandSide );
- void addRules ( SymbolType leftHandSide, ext::set < std::pair < SymbolType, ext::vector < SymbolType > > > rightHandSide );
+ void addRules ( SymbolType leftHandSide, ext::set < ext::pair < SymbolType, ext::vector < SymbolType > > > rightHandSide );
- const ext::map < SymbolType, ext::set < std::pair < SymbolType, ext::vector < SymbolType > > > > & getRules ( ) const;
+ const ext::map < SymbolType, ext::set < ext::pair < SymbolType, ext::vector < SymbolType > > > > & getRules ( ) const;
- bool removeRule ( const SymbolType & leftHandSide, const std::pair < SymbolType, ext::vector < SymbolType > > & rightHandSide );
+ bool removeRule ( const SymbolType & leftHandSide, const ext::pair < SymbolType, ext::vector < SymbolType > > & rightHandSide );
bool addRawRule ( SymbolType leftHandSide, ext::vector < SymbolType > rightHandSide );
@@ -136,10 +136,10 @@ public:
GNF < > * res = new GNF < > ( std::move ( nonterminals ), std::move ( terminals ), std::move ( initialSymbol ) );
- for ( std::pair < SymbolType, ext::set < std::pair < SymbolType, ext::vector < SymbolType > > > > && rule : ext::make_moveable_map ( rules ) ) {
+ for ( std::pair < SymbolType, ext::set < ext::pair < SymbolType, ext::vector < SymbolType > > > > && rule : ext::make_moveable_map ( rules ) ) {
- ext::set < std::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > > rhs;
- for ( std::pair < SymbolType, ext::vector < SymbolType > > && target : ext::make_moveable_set ( rule.second ) )
+ ext::set < ext::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > > rhs;
+ for ( ext::pair < SymbolType, ext::vector < SymbolType > > && target : ext::make_moveable_set ( rule.second ) )
rhs.insert ( GrammarNormalize::normalizeRHS ( std::move ( target ) ) );
DefaultSymbolType lhs = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( rule.first ) );
@@ -172,7 +172,7 @@ GrammarBase * GNF < SymbolType >::plunder ( ) && {
}
template < class SymbolType >
-bool GNF < SymbolType >::addRule ( SymbolType leftHandSide, std::pair < SymbolType, ext::vector < SymbolType > > rightHandSide ) {
+bool GNF < SymbolType >::addRule ( SymbolType leftHandSide, ext::pair < SymbolType, ext::vector < SymbolType > > rightHandSide ) {
if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
throw GrammarException ( "Rule must rewrite nonterminal symbol" );
@@ -187,7 +187,7 @@ bool GNF < SymbolType >::addRule ( SymbolType leftHandSide, std::pair < SymbolTy
}
template < class SymbolType >
-void GNF < SymbolType >::addRules ( SymbolType leftHandSide, ext::set < std::pair < SymbolType, ext::vector < SymbolType > > > rightHandSide ) {
+void GNF < SymbolType >::addRules ( SymbolType leftHandSide, ext::set < ext::pair < SymbolType, ext::vector < SymbolType > > > rightHandSide ) {
if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
throw GrammarException ( "Rule must rewrite nonterminal symbol" );
@@ -204,12 +204,12 @@ void GNF < SymbolType >::addRules ( SymbolType leftHandSide, ext::set < std::pai
}
template < class SymbolType >
-const ext::map < SymbolType, ext::set < std::pair < SymbolType, ext::vector < SymbolType > > > > & GNF < SymbolType >::getRules ( ) const {
+const ext::map < SymbolType, ext::set < ext::pair < SymbolType, ext::vector < SymbolType > > > > & GNF < SymbolType >::getRules ( ) const {
return rules;
}
template < class SymbolType >
-bool GNF < SymbolType >::removeRule ( const SymbolType & leftHandSide, const std::pair < SymbolType, ext::vector < SymbolType > > & rightHandSide ) {
+bool GNF < SymbolType >::removeRule ( const SymbolType & leftHandSide, const ext::pair < SymbolType, ext::vector < SymbolType > > & rightHandSide ) {
return rules[leftHandSide].erase ( rightHandSide );
}
@@ -224,7 +224,7 @@ bool GNF < SymbolType >::addRawRule ( SymbolType leftHandSide, ext::vector < Sym
} else {
SymbolType first = std::move ( rightHandSide[0] );
ext::vector < SymbolType > rest ( std::make_move_iterator ( rightHandSide.begin ( ) ) + 1, std::make_move_iterator ( rightHandSide.end ( ) ) );
- return addRule ( std::move ( leftHandSide ), std::make_pair ( std::move ( first ), std::move ( rest ) ) );
+ return addRule ( std::move ( leftHandSide ), ext::make_pair ( std::move ( first ), std::move ( rest ) ) );
}
}
@@ -256,7 +256,7 @@ bool GNF < SymbolType >::removeRawRule ( const SymbolType & leftHandSide, const
} else {
SymbolType first = rightHandSide[0];
ext::vector < SymbolType > rest ( rightHandSide.begin ( ) + 1, rightHandSide.end ( ) );
- return removeRule ( leftHandSide, std::make_pair ( first, rest ) );
+ return removeRule ( leftHandSide, ext::make_pair ( first, rest ) );
}
}
@@ -321,7 +321,7 @@ GNF < SymbolType > GNF < SymbolType >::parse ( ext::deque < sax::Token >::iterat
template < class SymbolType >
void GNF < SymbolType >::parseRule ( ext::deque < sax::Token >::iterator & input, GNF & grammar ) {
SymbolType lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS < SymbolType > ( input );
- std::pair < SymbolType, ext::vector < SymbolType > > rhs = GrammarFromXMLParser::parseRuleGNFRHS < SymbolType > ( input );
+ ext::pair < SymbolType, ext::vector < SymbolType > > rhs = GrammarFromXMLParser::parseRuleGNFRHS < SymbolType > ( input );
grammar.addRule ( std::move ( lhs ), std::move ( rhs ) );
}
@@ -370,7 +370,7 @@ template < class SymbolType >
class ComponentConstraint< grammar::GNF < SymbolType >, SymbolType, grammar::TerminalAlphabet > {
public:
static bool used ( const grammar::GNF < SymbolType > & grammar, const SymbolType & symbol ) {
- for ( const std::pair < const SymbolType, ext::set < std::pair < SymbolType, ext::vector < SymbolType > > > > & rule : grammar.getRules ( ) )
+ for ( const std::pair < const SymbolType, ext::set < ext::pair < SymbolType, ext::vector < SymbolType > > > > & rule : grammar.getRules ( ) )
for ( const std::pair < SymbolType, ext::vector < SymbolType > > & rhs : rule.second )
if ( rhs.first == symbol )
return true;
@@ -392,7 +392,7 @@ template < class SymbolType >
class ComponentConstraint< grammar::GNF < SymbolType >, SymbolType, grammar::NonterminalAlphabet > {
public:
static bool used ( const grammar::GNF < SymbolType > & grammar, const SymbolType & symbol ) {
- for ( const std::pair < const SymbolType, ext::set < std::pair < SymbolType, ext::vector < SymbolType > > > > & rule : grammar.getRules ( ) ) {
+ for ( const std::pair < const SymbolType, ext::set < ext::pair < SymbolType, ext::vector < SymbolType > > > > & rule : grammar.getRules ( ) ) {
if ( rule.first == symbol )
return true;
diff --git a/alib2data/src/grammar/Regular/LeftLG.h b/alib2data/src/grammar/Regular/LeftLG.h
index 09ef1f18ba8715249434c8a6e889113acc7e3961..9d157afcc40c002774b676de1ff76725573d16c2 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.
*/
- ext::map < SymbolType, ext::set < ext::variant < ext::vector < SymbolType >, std::pair < SymbolType, ext::vector < SymbolType > > > > > rules;
+ ext::map < SymbolType, ext::set < ext::variant < ext::vector < SymbolType >, ext::pair < SymbolType, ext::vector < SymbolType > > > > > rules;
public:
/**
@@ -106,7 +106,7 @@ public:
*
* \returns true if the rule was indeed added, false othervise
*/
- bool addRule ( SymbolType leftHandSide, ext::variant < ext::vector < SymbolType >, std::pair < SymbolType, ext::vector < SymbolType > > > rightHandSide );
+ bool addRule ( SymbolType leftHandSide, ext::variant < ext::vector < SymbolType >, ext::pair < SymbolType, ext::vector < SymbolType > > > rightHandSide );
/**
* \brief Add a new rule of a grammar.
@@ -130,7 +130,7 @@ public:
*
* \returns true if the rule was indeed added, false othervise
*/
- bool addRule ( SymbolType leftHandSide, std::pair < SymbolType, ext::vector < SymbolType > > rightHandSide );
+ bool addRule ( SymbolType leftHandSide, ext::pair < SymbolType, ext::vector < SymbolType > > rightHandSide );
/**
* \brief Add new rules 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, ext::set < ext::variant < ext::vector < SymbolType >, std::pair < SymbolType, ext::vector < SymbolType > > > > rightHandSide );
+ void addRules ( SymbolType leftHandSide, ext::set < ext::variant < ext::vector < SymbolType >, ext::pair < SymbolType, ext::vector < SymbolType > > > > rightHandSide );
/**
* Get rules of the grammar.
*
* \returns rules of the grammar
*/
- const ext::map < SymbolType, ext::set < ext::variant < ext::vector < SymbolType >, std::pair < SymbolType, ext::vector < SymbolType > > > > > & getRules ( ) const;
+ const ext::map < SymbolType, ext::set < ext::variant < ext::vector < SymbolType >, ext::pair < SymbolType, ext::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 ext::variant < ext::vector < SymbolType >, std::pair < SymbolType, ext::vector < SymbolType > > > & rightHandSide );
+ bool removeRule ( const SymbolType & leftHandSide, const ext::variant < ext::vector < SymbolType >, ext::pair < SymbolType, ext::vector < SymbolType > > > & rightHandSide );
/**
* Remove a rule of a grammar in form of A -> a, where A \in N and a \in T*.
@@ -177,7 +177,7 @@ public:
*
* \returns true if the rule was indeed removed, false othervise
*/
- bool removeRule ( const SymbolType & leftHandSide, const std::pair < SymbolType, ext::vector < SymbolType > > & rightHandSide );
+ bool removeRule ( const SymbolType & leftHandSide, const ext::pair < SymbolType, ext::vector < SymbolType > > & rightHandSide );
/**
* Add a new rule of a grammar in form of A -> aB or A -> a, where A, B \in N and a \in T* as stored in combination of leftHandSide and rightHandSide represented as vector of symbols.
@@ -378,10 +378,10 @@ public:
LeftLG < > * res = new LeftLG < > ( std::move ( nonterminals ), std::move ( terminals ), std::move ( initialSymbol ) );
- for ( std::pair < SymbolType, ext::set < ext::variant < ext::vector < SymbolType >, std::pair < SymbolType, ext::vector < SymbolType > > > > > && rule : ext::make_moveable_map ( rules ) ) {
+ for ( std::pair < SymbolType, ext::set < ext::variant < ext::vector < SymbolType >, ext::pair < SymbolType, ext::vector < SymbolType > > > > > && rule : ext::make_moveable_map ( rules ) ) {
- ext::set < ext::variant < ext::vector < DefaultSymbolType >, std::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > > > rhs;
- for ( ext::variant < ext::vector < SymbolType >, std::pair < SymbolType, ext::vector < SymbolType > > > && target : ext::make_moveable_set ( rule.second ) )
+ ext::set < ext::variant < ext::vector < DefaultSymbolType >, ext::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > > > rhs;
+ for ( ext::variant < ext::vector < SymbolType >, ext::pair < SymbolType, ext::vector < SymbolType > > > && target : ext::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, ext::variant < ext::vector < SymbolType >, std::pair < SymbolType, ext::vector < SymbolType > > > rightHandSide ) {
+bool LeftLG < SymbolType >::addRule ( SymbolType leftHandSide, ext::variant < ext::vector < SymbolType >, ext::pair < SymbolType, ext::vector < SymbolType > > > rightHandSide ) {
if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
throw GrammarException ( "Rule must rewrite nonterminal symbol" );
@@ -422,7 +422,7 @@ bool LeftLG < SymbolType >::addRule ( SymbolType leftHandSide, ext::variant < ex
if ( !getTerminalAlphabet ( ).count ( symbol ) )
throw GrammarException ( "Symbol " + ext::to_string ( symbol ) + " is not a terminal symbol" );
} else {
- const std::pair < SymbolType, ext::vector < SymbolType > > & rhs = rightHandSide.template get < std::pair < SymbolType, ext::vector < SymbolType > > > ( );
+ const ext::pair < SymbolType, ext::vector < SymbolType > > & rhs = rightHandSide.template get < ext::pair < SymbolType, ext::vector < SymbolType > > > ( );
if ( !getNonterminalAlphabet ( ).count ( rhs.first ) )
throw GrammarException ( "Symbol " + ext::to_string ( rhs.first ) + " is not a nonterminal symbol" );
@@ -437,31 +437,31 @@ bool LeftLG < SymbolType >::addRule ( SymbolType leftHandSide, ext::variant < ex
template < class SymbolType >
bool LeftLG < SymbolType >::addRule ( SymbolType leftHandSide, ext::vector < SymbolType > rightHandSide ) {
- ext::variant < ext::vector < SymbolType >, std::pair < SymbolType, ext::vector < SymbolType > > > rhs ( std::move ( rightHandSide ) );
+ ext::variant < ext::vector < SymbolType >, ext::pair < SymbolType, ext::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, ext::vector < SymbolType > > rightHandSide ) {
- ext::variant < ext::vector < SymbolType >, std::pair < SymbolType, ext::vector < SymbolType > > > rhs ( std::move ( rightHandSide ) );
+bool LeftLG < SymbolType >::addRule ( SymbolType leftHandSide, ext::pair < SymbolType, ext::vector < SymbolType > > rightHandSide ) {
+ ext::variant < ext::vector < SymbolType >, ext::pair < SymbolType, ext::vector < SymbolType > > > rhs ( std::move ( rightHandSide ) );
return addRule ( std::move ( leftHandSide ), std::move ( rhs ) );
}
template < class SymbolType >
-void LeftLG < SymbolType >::addRules ( SymbolType leftHandSide, ext::set < ext::variant < ext::vector < SymbolType >, std::pair < SymbolType, ext::vector < SymbolType > > > > rightHandSide ) {
+void LeftLG < SymbolType >::addRules ( SymbolType leftHandSide, ext::set < ext::variant < ext::vector < SymbolType >, ext::pair < SymbolType, ext::vector < SymbolType > > > > rightHandSide ) {
if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
throw GrammarException ( "Rule must rewrite nonterminal symbol" );
- for ( const ext::variant < ext::vector < SymbolType >, std::pair < SymbolType, ext::vector < SymbolType > > > & element : rightHandSide ) {
+ for ( const ext::variant < ext::vector < SymbolType >, ext::pair < SymbolType, ext::vector < SymbolType > > > & element : rightHandSide ) {
if ( element.template is < ext::vector < SymbolType > > ( ) ) {
for ( const auto & symbol : element.template get < ext::vector < SymbolType > > ( ) )
if ( !getTerminalAlphabet ( ).count ( symbol ) )
throw GrammarException ( "Symbol " + ext::to_string ( symbol ) + " is not a terminal symbol" );
} else {
- const std::pair < SymbolType, ext::vector < SymbolType > > & rhs = element.template get < std::pair < SymbolType, ext::vector < SymbolType > > > ( );
+ const ext::pair < SymbolType, ext::vector < SymbolType > > & rhs = element.template get < ext::pair < SymbolType, ext::vector < SymbolType > > > ( );
if ( !getNonterminalAlphabet ( ).count ( rhs.first ) )
throw GrammarException ( "Symbol " + ext::to_string ( rhs.first ) + " is not a nonterminal symbol" );
@@ -477,25 +477,25 @@ void LeftLG < SymbolType >::addRules ( SymbolType leftHandSide, ext::set < ext::
}
template < class SymbolType >
-const ext::map < SymbolType, ext::set < ext::variant < ext::vector < SymbolType >, std::pair < SymbolType, ext::vector < SymbolType > > > > > & LeftLG < SymbolType >::getRules ( ) const {
+const ext::map < SymbolType, ext::set < ext::variant < ext::vector < SymbolType >, ext::pair < SymbolType, ext::vector < SymbolType > > > > > & LeftLG < SymbolType >::getRules ( ) const {
return rules;
}
template < class SymbolType >
-bool LeftLG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const ext::variant < ext::vector < SymbolType >, std::pair < SymbolType, ext::vector < SymbolType > > > & rightHandSide ) {
+bool LeftLG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const ext::variant < ext::vector < SymbolType >, ext::pair < SymbolType, ext::vector < SymbolType > > > & rightHandSide ) {
return rules[leftHandSide].erase ( rightHandSide );
}
template < class SymbolType >
bool LeftLG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const ext::vector < SymbolType > & rightHandSide ) {
- ext::variant < ext::vector < SymbolType >, std::pair < SymbolType, ext::vector < SymbolType > > > rhs ( rightHandSide );
+ ext::variant < ext::vector < SymbolType >, ext::pair < SymbolType, ext::vector < SymbolType > > > rhs ( rightHandSide );
return removeRule ( leftHandSide, rhs );
}
template < class SymbolType >
-bool LeftLG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const std::pair < SymbolType, ext::vector < SymbolType > > & rightHandSide ) {
- ext::variant < ext::vector < SymbolType >, std::pair < SymbolType, ext::vector < SymbolType > > > rhs ( rightHandSide );
+bool LeftLG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const ext::pair < SymbolType, ext::vector < SymbolType > > & rightHandSide ) {
+ ext::variant < ext::vector < SymbolType >, ext::pair < SymbolType, ext::vector < SymbolType > > > rhs ( rightHandSide );
return removeRule ( leftHandSide, rhs );
}
@@ -505,7 +505,7 @@ bool LeftLG < SymbolType >::addRawRule ( SymbolType leftHandSide, ext::vector <
if ( rightHandSide.size ( ) == 0 )
return addRule ( std::move ( leftHandSide ), std::move ( rightHandSide ) );
else if ( getNonterminalAlphabet ( ).count ( rightHandSide[0] ) )
- return addRule ( std::move ( leftHandSide ), std::make_pair ( std::move ( rightHandSide[0] ), ext::vector < SymbolType > ( std::make_move_iterator ( rightHandSide.begin ( ) ), std::make_move_iterator ( rightHandSide.end ( ) ) ) ) );
+ return addRule ( std::move ( leftHandSide ), ext::make_pair ( std::move ( rightHandSide[0] ), ext::vector < SymbolType > ( std::make_move_iterator ( rightHandSide.begin ( ) ), std::make_move_iterator ( rightHandSide.end ( ) ) ) ) );
else
return addRule ( std::move ( leftHandSide ), std::move ( rightHandSide ) );
}
@@ -519,7 +519,7 @@ ext::map < SymbolType, ext::set < ext::vector < SymbolType > > > LeftLG < Symbol
if ( rhs.template is < ext::vector < SymbolType > > ( ) ) {
res[rule.first].insert ( rhs.template get < ext::vector < SymbolType > > ( ) );
} else {
- const auto & rhsTuple = rhs.template get < std::pair < SymbolType, ext::vector < SymbolType > > > ( );
+ const auto & rhsTuple = rhs.template get < ext::pair < SymbolType, ext::vector < SymbolType > > > ( );
ext::vector < SymbolType > tmp { rhsTuple.first };
tmp.insert ( tmp.end ( ), rhsTuple.second.begin ( ), rhsTuple.second.end ( ) );
res[rule.first].insert ( std::move ( tmp ) );
@@ -534,7 +534,7 @@ bool LeftLG < SymbolType >::removeRawRule ( const SymbolType & leftHandSide, con
if ( rightHandSide.size ( ) == 0 )
return removeRule ( leftHandSide, rightHandSide );
else if ( getNonterminalAlphabet ( ).count ( rightHandSide[0] ) )
- return removeRule ( leftHandSide, std::make_pair ( rightHandSide[0], ext::vector < SymbolType > ( rightHandSide.begin ( ) + 1, rightHandSide.end ( ) ) ) );
+ return removeRule ( leftHandSide, ext::make_pair ( rightHandSide[0], ext::vector < SymbolType > ( rightHandSide.begin ( ) + 1, rightHandSide.end ( ) ) ) );
else
return removeRule ( leftHandSide, rightHandSide );
}
@@ -648,15 +648,15 @@ 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, ext::set < ext::variant < ext::vector < SymbolType >, std::pair < SymbolType, ext::vector < SymbolType > > > > > & rule : grammar.getRules ( ) ) {
- for ( const ext::variant < ext::vector < SymbolType >, std::pair < SymbolType, ext::vector < SymbolType > > > & rhsTmp : rule.second )
+ for ( const std::pair < const SymbolType, ext::set < ext::variant < ext::vector < SymbolType >, ext::pair < SymbolType, ext::vector < SymbolType > > > > > & rule : grammar.getRules ( ) ) {
+ for ( const ext::variant < ext::vector < SymbolType >, ext::pair < SymbolType, ext::vector < SymbolType > > > & rhsTmp : rule.second )
if ( rhsTmp.template is < ext::vector < SymbolType > > ( ) ) {
const ext::vector < SymbolType > & rhs = rhsTmp.template get < ext::vector < SymbolType > > ( );
if ( std::find ( rhs.begin ( ), rhs.end ( ), symbol ) != rhs.end ( ) )
return true;
} else {
- const std::pair < SymbolType, ext::vector < SymbolType > > & rhs = rhsTmp.template get < std::pair < SymbolType, ext::vector < SymbolType > > > ( );
+ const ext::pair < SymbolType, ext::vector < SymbolType > > & rhs = rhsTmp.template get < ext::pair < SymbolType, ext::vector < SymbolType > > > ( );
if ( std::find ( rhs.second.begin ( ), rhs.second.end ( ), symbol ) != rhs.second.end ( ) )
return true;
@@ -707,13 +707,13 @@ 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, ext::set < ext::variant < ext::vector < SymbolType >, std::pair < SymbolType, ext::vector < SymbolType > > > > > & rule : grammar.getRules ( ) ) {
+ for ( const std::pair < const SymbolType, ext::set < ext::variant < ext::vector < SymbolType >, ext::pair < SymbolType, ext::vector < SymbolType > > > > > & rule : grammar.getRules ( ) ) {
if ( rule.first == symbol )
return true;
- for ( const ext::variant < ext::vector < SymbolType >, std::pair < SymbolType, ext::vector < SymbolType > > > & rhsTmp : rule.second )
- if ( rhsTmp.template is < std::pair < SymbolType, ext::vector < SymbolType > > > ( ) ) {
- const std::pair < SymbolType, ext::vector < SymbolType > > & rhs = rhsTmp.template get < std::pair < SymbolType, ext::vector < SymbolType > > > ( );
+ for ( const ext::variant < ext::vector < SymbolType >, ext::pair < SymbolType, ext::vector < SymbolType > > > & rhsTmp : rule.second )
+ if ( rhsTmp.template is < ext::pair < SymbolType, ext::vector < SymbolType > > > ( ) ) {
+ const ext::pair < SymbolType, ext::vector < SymbolType > > & rhs = rhsTmp.template get < ext::pair < SymbolType, ext::vector < SymbolType > > > ( );
if ( rhs.first == symbol )
return true;
diff --git a/alib2data/src/grammar/Regular/LeftRG.h b/alib2data/src/grammar/Regular/LeftRG.h
index 2245d7c49f4696d7aec28176c98024702380eb20..f4a165a914eb41749728f1b448cb4d535ebeac32 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.
*/
- ext::map < SymbolType, ext::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > rules;
+ ext::map < SymbolType, ext::set < ext::variant < SymbolType, ext::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, ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rightHandSide );
+ bool addRule ( SymbolType leftHandSide, ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > rightHandSide );
/**
* \brief Add a new rule of a grammar.
@@ -139,7 +139,7 @@ public:
*
* \returns true if the rule was indeed added, false othervise
*/
- bool addRule ( SymbolType leftHandSide, std::pair < SymbolType, SymbolType > rightHandSide );
+ bool addRule ( SymbolType leftHandSide, ext::pair < SymbolType, SymbolType > rightHandSide );
/**
* \brief Add new rules 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, ext::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > rightHandSide );
+ void addRules ( SymbolType leftHandSide, ext::set < ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > > rightHandSide );
/**
* Get rules of the grammar.
*
* \returns rules of the grammar
*/
- const ext::map < SymbolType, ext::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & getRules ( ) const;
+ const ext::map < SymbolType, ext::set < ext::variant < SymbolType, ext::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 ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rightHandSide );
+ bool removeRule ( const SymbolType & leftHandSide, const ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > & rightHandSide );
/**
* Remove a rule of a grammar in form of A -> a, where A \in N and a \in T.
@@ -186,7 +186,7 @@ public:
*
* \returns true if the rule was indeed removed, false othervise
*/
- bool removeRule ( const SymbolType & leftHandSide, const std::pair < SymbolType, SymbolType > & rightHandSide );
+ bool removeRule ( const SymbolType & leftHandSide, const ext::pair < SymbolType, SymbolType > & rightHandSide );
/**
* Add a new rule of a grammar in form of A -> aB or A -> a, where A, B \in N and a \in T as stored in combination of leftHandSide and rightHandSide represented as vector of symbols.
@@ -401,10 +401,10 @@ public:
LeftRG < > * res = new LeftRG < > ( std::move ( nonterminals ), std::move ( terminals ), std::move ( initialSymbol ) );
- for ( std::pair < SymbolType, ext::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > && rule : ext::make_moveable_map ( rules ) ) {
+ for ( std::pair < SymbolType, ext::set < ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > > > && rule : ext::make_moveable_map ( rules ) ) {
- ext::set < ext::variant < DefaultSymbolType, std::pair < DefaultSymbolType, DefaultSymbolType > > > rhs;
- for ( ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > && target : ext::make_moveable_set ( rule.second ) )
+ ext::set < ext::variant < DefaultSymbolType, ext::pair < DefaultSymbolType, DefaultSymbolType > > > rhs;
+ for ( ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > && target : ext::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, ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rightHandSide ) {
+bool LeftRG < SymbolType >::addRule ( SymbolType leftHandSide, ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > rightHandSide ) {
if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
throw GrammarException ( "Rule must rewrite nonterminal symbol" );
@@ -447,7 +447,7 @@ bool LeftRG < SymbolType >::addRule ( SymbolType leftHandSide, ext::variant < Sy
if ( !getTerminalAlphabet ( ).count ( rhs ) )
throw GrammarException ( "Rule must rewrite to terminal symbol" );
} else {
- const std::pair < SymbolType, SymbolType > & rhs = rightHandSide.template get < std::pair < SymbolType, SymbolType > > ( );
+ const ext::pair < SymbolType, SymbolType > & rhs = rightHandSide.template get < ext::pair < SymbolType, SymbolType > > ( );
if ( !getNonterminalAlphabet ( ).count ( rhs.first ) || !getTerminalAlphabet ( ).count ( rhs.second ) )
throw GrammarException ( "Rule must rewrite to terminal symbol followed by nonterminal symbol" );
@@ -457,11 +457,11 @@ bool LeftRG < SymbolType >::addRule ( SymbolType leftHandSide, ext::variant < Sy
}
template < class SymbolType >
-void LeftRG < SymbolType >::addRules ( SymbolType leftHandSide, ext::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > rightHandSide ) {
+void LeftRG < SymbolType >::addRules ( SymbolType leftHandSide, ext::set < ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > > rightHandSide ) {
if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
throw GrammarException ( "Rule must rewrite nonterminal symbol" );
- for ( const ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > & element : rightHandSide ) {
+ for ( const ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > & element : rightHandSide ) {
if ( element.template is < SymbolType > ( ) ) {
const SymbolType & rhs = element.template get < SymbolType > ( );
@@ -469,7 +469,7 @@ void LeftRG < SymbolType >::addRules ( SymbolType leftHandSide, ext::set < ext::
throw GrammarException ( "Rule must rewrite to terminal symbol" );
} else {
- const std::pair < SymbolType, SymbolType > & rhs = element.template get < std::pair < SymbolType, SymbolType > > ( );
+ const ext::pair < SymbolType, SymbolType > & rhs = element.template get < ext::pair < SymbolType, SymbolType > > ( );
if ( ! getNonterminalAlphabet ( ).count ( rhs.first ) || ! getTerminalAlphabet ( ).count ( rhs.second ) )
throw GrammarException ( "Rule must rewrite to terminal symbol followed by nonterminal symbol" );
@@ -481,38 +481,38 @@ void LeftRG < SymbolType >::addRules ( SymbolType leftHandSide, ext::set < ext::
template < class SymbolType >
bool LeftRG < SymbolType >::addRule ( SymbolType leftHandSide, SymbolType rightHandSide ) {
- ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( std::move ( rightHandSide ) );
+ ext::variant < SymbolType, ext::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 ) {
- ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( std::move ( rightHandSide ) );
+bool LeftRG < SymbolType >::addRule ( SymbolType leftHandSide, ext::pair < SymbolType, SymbolType > rightHandSide ) {
+ ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > rhs ( std::move ( rightHandSide ) );
return addRule ( std::move ( leftHandSide ), std::move ( rhs ) );
}
template < class SymbolType >
-const ext::map < SymbolType, ext::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & LeftRG < SymbolType >::getRules ( ) const {
+const ext::map < SymbolType, ext::set < ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > > > & LeftRG < SymbolType >::getRules ( ) const {
return rules;
}
template < class SymbolType >
-bool LeftRG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rightHandSide ) {
+bool LeftRG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > & rightHandSide ) {
return rules[leftHandSide].erase ( rightHandSide );
}
template < class SymbolType >
bool LeftRG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const SymbolType & rightHandSide ) {
- ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( rightHandSide );
+ ext::variant < SymbolType, ext::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 ) {
- ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( rightHandSide );
+bool LeftRG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const ext::pair < SymbolType, SymbolType > & rightHandSide ) {
+ ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > rhs ( rightHandSide );
return removeRule ( leftHandSide, rhs );
}
@@ -528,7 +528,7 @@ bool LeftRG < SymbolType >::addRawRule ( SymbolType leftHandSide, ext::vector <
} else if ( rightHandSide.size ( ) == 1 ) {
return addRule ( std::move ( leftHandSide ), std::move ( rightHandSide[0] ) );
} else if ( rightHandSide.size ( ) == 2 ) {
- return addRule ( std::move ( leftHandSide ), std::make_pair ( std::move ( rightHandSide[0] ), std::move ( rightHandSide[1] ) ) );
+ return addRule ( std::move ( leftHandSide ), ext::make_pair ( std::move ( rightHandSide[0] ), std::move ( rightHandSide[1] ) ) );
} else {
throw GrammarException ( "Invalid right hand side" );
}
@@ -544,7 +544,7 @@ ext::map < SymbolType, ext::set < ext::vector < SymbolType > > > LeftRG < Symbol
ext::vector < SymbolType > tmp { rhs.template get < SymbolType > ( ) };
res[rule.first].insert ( std::move ( tmp ) );
} else {
- const auto & rhsPair = rhs.template get < std::pair < SymbolType, SymbolType > > ( );
+ const auto & rhsPair = rhs.template get < ext::pair < SymbolType, SymbolType > > ( );
ext::vector < SymbolType > tmp { rhsPair.first, rhsPair.second };
res[rule.first].insert ( std::move ( tmp ) );
}
@@ -567,7 +567,7 @@ bool LeftRG < SymbolType >::removeRawRule ( const SymbolType & leftHandSide, con
} else if ( rightHandSide.size ( ) == 1 ) {
return removeRule ( leftHandSide, rightHandSide[0] );
} else if ( rightHandSide.size ( ) == 2 ) {
- return removeRule ( leftHandSide, std::make_pair ( rightHandSide[0], rightHandSide[1] ) );
+ return removeRule ( leftHandSide, ext::make_pair ( rightHandSide[0], rightHandSide[1] ) );
} else {
throw GrammarException ( "Invalid right hand side" );
}
@@ -635,7 +635,7 @@ LeftRG < SymbolType > LeftRG < SymbolType >::parse ( ext::deque < sax::Token >::
template < class SymbolType >
void LeftRG < SymbolType >::parseRule ( ext::deque < sax::Token >::iterator & input, LeftRG & grammar ) {
SymbolType lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS < SymbolType > ( input );
- ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs = GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS < SymbolType > ( input );
+ ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > rhs = GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS < SymbolType > ( input );
grammar.addRule ( std::move ( lhs ), std::move ( rhs ) );
}
@@ -697,9 +697,9 @@ 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, ext::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 ) )
+ for ( const std::pair < const SymbolType, ext::set < ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > > > & rule : grammar.getRules ( ) )
+ for ( const ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > & rhs : rule.second )
+ if ( ( rhs.template is < SymbolType > ( ) && ( rhs.template get < SymbolType > ( ) == symbol ) ) || ( rhs.template get < ext::pair < SymbolType, SymbolType > > ( ).first == symbol ) )
return true;
return false;
@@ -745,12 +745,12 @@ 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, ext::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & rule : grammar.getRules ( ) ) {
+ for ( const std::pair < const SymbolType, ext::set < ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > > > & rule : grammar.getRules ( ) ) {
if ( rule.first == symbol )
return true;
- for ( const ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rhs : rule.second )
- if ( rhs.template get < std::pair < SymbolType, SymbolType > > ( ).second == symbol )
+ for ( const ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > & rhs : rule.second )
+ if ( rhs.template get < ext::pair < SymbolType, SymbolType > > ( ).second == symbol )
return true;
}
diff --git a/alib2data/src/grammar/Regular/RightLG.h b/alib2data/src/grammar/Regular/RightLG.h
index f37a5740b3334270099ec279c2b7f89c64d4e2cb..620794d44cb18ac52d7f931c6bd525de466ffb77 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.
*/
- ext::map < SymbolType, ext::set < ext::variant < ext::vector < SymbolType >, std::pair < ext::vector < SymbolType >, SymbolType > > > > rules;
+ ext::map < SymbolType, ext::set < ext::variant < ext::vector < SymbolType >, ext::pair < ext::vector < SymbolType >, SymbolType > > > > rules;
public:
/**
@@ -106,7 +106,7 @@ public:
*
* \returns true if the rule was indeed added, false othervise
*/
- bool addRule ( SymbolType leftHandSide, ext::variant < ext::vector < SymbolType >, std::pair < ext::vector < SymbolType >, SymbolType > > rightHandSide );
+ bool addRule ( SymbolType leftHandSide, ext::variant < ext::vector < SymbolType >, ext::pair < ext::vector < SymbolType >, SymbolType > > rightHandSide );
/**
* \brief Add a new rule of a grammar.
@@ -130,7 +130,7 @@ public:
*
* \returns true if the rule was indeed added, false othervise
*/
- bool addRule ( SymbolType leftHandSide, std::pair < ext::vector < SymbolType >, SymbolType > rightHandSide );
+ bool addRule ( SymbolType leftHandSide, ext::pair < ext::vector < SymbolType >, SymbolType > rightHandSide );
/**
* \brief Add new rules 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, ext::set < ext::variant < ext::vector < SymbolType >, std::pair < ext::vector < SymbolType >, SymbolType > > > rightHandSide );
+ void addRules ( SymbolType leftHandSide, ext::set < ext::variant < ext::vector < SymbolType >, ext::pair < ext::vector < SymbolType >, SymbolType > > > rightHandSide );
/**
* Get rules of the grammar.
*
* \returns rules of the grammar
*/
- const ext::map < SymbolType, ext::set < ext::variant < ext::vector < SymbolType >, std::pair < ext::vector < SymbolType >, SymbolType > > > > & getRules ( ) const;
+ const ext::map < SymbolType, ext::set < ext::variant < ext::vector < SymbolType >, ext::pair < ext::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 ext::variant < ext::vector < SymbolType >, std::pair < ext::vector < SymbolType >, SymbolType > > & rightHandSide );
+ bool removeRule ( const SymbolType & leftHandSide, const ext::variant < ext::vector < SymbolType >, ext::pair < ext::vector < SymbolType >, SymbolType > > & rightHandSide );
/**
* Remove a rule of a grammar in form of A -> a, where A \in N and a \in T*.
@@ -177,7 +177,7 @@ public:
*
* \returns true if the rule was indeed removed, false othervise
*/
- bool removeRule ( const SymbolType & leftHandSide, const std::pair < ext::vector < SymbolType >, SymbolType > & rightHandSide );
+ bool removeRule ( const SymbolType & leftHandSide, const ext::pair < ext::vector < SymbolType >, SymbolType > & rightHandSide );
/**
* Add a new rule of a grammar in form of A -> Ba or A -> a, where A, B \in N and a \in T* as stored in combination of leftHandSide and rightHandSide represented as vector of symbols.
@@ -378,10 +378,10 @@ public:
RightLG < > * res = new RightLG < > ( std::move ( nonterminals ), std::move ( terminals ), std::move ( initialSymbol ) );
- for ( std::pair < SymbolType, ext::set < ext::variant < ext::vector < SymbolType >, std::pair < ext::vector < SymbolType >, SymbolType > > > > && rule : ext::make_moveable_map ( rules ) ) {
+ for ( std::pair < SymbolType, ext::set < ext::variant < ext::vector < SymbolType >, ext::pair < ext::vector < SymbolType >, SymbolType > > > > && rule : ext::make_moveable_map ( rules ) ) {
- ext::set < ext::variant < ext::vector < DefaultSymbolType >, std::pair < ext::vector < DefaultSymbolType >, DefaultSymbolType > > > rhs;
- for ( ext::variant < ext::vector < SymbolType >, std::pair < ext::vector < SymbolType >, SymbolType > > && target : ext::make_moveable_set ( rule.second ) )
+ ext::set < ext::variant < ext::vector < DefaultSymbolType >, ext::pair < ext::vector < DefaultSymbolType >, DefaultSymbolType > > > rhs;
+ for ( ext::variant < ext::vector < SymbolType >, ext::pair < ext::vector < SymbolType >, SymbolType > > && target : ext::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, ext::variant < ext::vector < SymbolType >, std::pair < ext::vector < SymbolType >, SymbolType > > rightHandSide ) {
+bool RightLG < SymbolType >::addRule ( SymbolType leftHandSide, ext::variant < ext::vector < SymbolType >, ext::pair < ext::vector < SymbolType >, SymbolType > > rightHandSide ) {
if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
throw GrammarException ( "Rule must rewrite nonterminal symbol" );
@@ -421,7 +421,7 @@ bool RightLG < SymbolType >::addRule ( SymbolType leftHandSide, ext::variant < e
if ( !getTerminalAlphabet ( ).count ( symbol ) )
throw GrammarException ( "Symbol " + ext::to_string ( symbol ) + " is not a terminal symbol" );
} else {
- const std::pair < ext::vector < SymbolType >, SymbolType > & rhs = rightHandSide.template get < std::pair < ext::vector < SymbolType >, SymbolType > > ( );
+ const ext::pair < ext::vector < SymbolType >, SymbolType > & rhs = rightHandSide.template get < ext::pair < ext::vector < SymbolType >, SymbolType > > ( );
if ( !getNonterminalAlphabet ( ).count ( rhs.second ) )
throw GrammarException ( "Symbol " + ext::to_string ( rhs.second ) + " is not a nonterminal symbol" );
@@ -436,30 +436,30 @@ bool RightLG < SymbolType >::addRule ( SymbolType leftHandSide, ext::variant < e
template < class SymbolType >
bool RightLG < SymbolType >::addRule ( SymbolType leftHandSide, ext::vector < SymbolType > rightHandSide ) {
- ext::variant < ext::vector < SymbolType >, std::pair < ext::vector < SymbolType >, SymbolType > > rhs ( std::move ( rightHandSide ) );
+ ext::variant < ext::vector < SymbolType >, ext::pair < ext::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 < ext::vector < SymbolType >, SymbolType > rightHandSide ) {
- ext::variant < ext::vector < SymbolType >, std::pair < ext::vector < SymbolType >, SymbolType > > rhs ( std::move ( rightHandSide ) );
+bool RightLG < SymbolType >::addRule ( SymbolType leftHandSide, ext::pair < ext::vector < SymbolType >, SymbolType > rightHandSide ) {
+ ext::variant < ext::vector < SymbolType >, ext::pair < ext::vector < SymbolType >, SymbolType > > rhs ( std::move ( rightHandSide ) );
return addRule ( std::move ( leftHandSide ), std::move ( rhs ) );
}
template < class SymbolType >
-void RightLG < SymbolType >::addRules ( SymbolType leftHandSide, ext::set < ext::variant < ext::vector < SymbolType >, std::pair < ext::vector < SymbolType >, SymbolType > > > rightHandSide ) {
+void RightLG < SymbolType >::addRules ( SymbolType leftHandSide, ext::set < ext::variant < ext::vector < SymbolType >, ext::pair < ext::vector < SymbolType >, SymbolType > > > rightHandSide ) {
if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
throw GrammarException ( "Rule must rewrite nonterminal symbol" );
- for ( const ext::variant < ext::vector < SymbolType >, std::pair < ext::vector < SymbolType >, SymbolType > > & element : rightHandSide ) {
+ for ( const ext::variant < ext::vector < SymbolType >, ext::pair < ext::vector < SymbolType >, SymbolType > > & element : rightHandSide ) {
if ( element.template is < ext::vector < SymbolType > > ( ) ) {
for ( const auto & symbol : element.template get < ext::vector < SymbolType > > ( ) )
if ( !getTerminalAlphabet ( ).count ( symbol ) )
throw GrammarException ( "Symbol " + ext::to_string ( symbol ) + " is not a terminal symbol" );
} else {
- const std::pair < ext::vector < SymbolType >, SymbolType > & rhs = element.template get < std::pair < ext::vector < SymbolType >, SymbolType > > ( );
+ const ext::pair < ext::vector < SymbolType >, SymbolType > & rhs = element.template get < ext::pair < ext::vector < SymbolType >, SymbolType > > ( );
if ( !getNonterminalAlphabet ( ).count ( rhs.second ) )
throw GrammarException ( "Symbol " + ext::to_string ( rhs.second ) + " is not a nonterminal symbol" );
@@ -474,25 +474,25 @@ void RightLG < SymbolType >::addRules ( SymbolType leftHandSide, ext::set < ext:
}
template < class SymbolType >
-const ext::map < SymbolType, ext::set < ext::variant < ext::vector < SymbolType >, std::pair < ext::vector < SymbolType >, SymbolType > > > > & RightLG < SymbolType >::getRules ( ) const {
+const ext::map < SymbolType, ext::set < ext::variant < ext::vector < SymbolType >, ext::pair < ext::vector < SymbolType >, SymbolType > > > > & RightLG < SymbolType >::getRules ( ) const {
return rules;
}
template < class SymbolType >
-bool RightLG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const ext::variant < ext::vector < SymbolType >, std::pair < ext::vector < SymbolType >, SymbolType > > & rightHandSide ) {
+bool RightLG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const ext::variant < ext::vector < SymbolType >, ext::pair < ext::vector < SymbolType >, SymbolType > > & rightHandSide ) {
return rules[leftHandSide].erase ( rightHandSide );
}
template < class SymbolType >
bool RightLG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const ext::vector < SymbolType > & rightHandSide ) {
- ext::variant < ext::vector < SymbolType >, std::pair < ext::vector < SymbolType >, SymbolType > > rhs ( rightHandSide );
+ ext::variant < ext::vector < SymbolType >, ext::pair < ext::vector < SymbolType >, SymbolType > > rhs ( rightHandSide );
return removeRule ( leftHandSide, rhs );
}
template < class SymbolType >
-bool RightLG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const std::pair < ext::vector < SymbolType >, SymbolType > & rightHandSide ) {
- ext::variant < ext::vector < SymbolType >, std::pair < ext::vector < SymbolType >, SymbolType > > rhs ( rightHandSide );
+bool RightLG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const ext::pair < ext::vector < SymbolType >, SymbolType > & rightHandSide ) {
+ ext::variant < ext::vector < SymbolType >, ext::pair < ext::vector < SymbolType >, SymbolType > > rhs ( rightHandSide );
return removeRule ( leftHandSide, rhs );
}
@@ -502,7 +502,7 @@ bool RightLG < SymbolType >::addRawRule ( SymbolType leftHandSide, ext::vector <
if ( rightHandSide.size ( ) == 0 )
return addRule ( std::move ( leftHandSide ), std::move ( rightHandSide ) );
else if ( getNonterminalAlphabet ( ).count ( rightHandSide[rightHandSide.size ( ) - 1] ) )
- return addRule ( std::move ( leftHandSide ), std::make_pair ( ext::vector < SymbolType > ( std::make_move_iterator ( rightHandSide.begin ( ) ), std::make_move_iterator ( rightHandSide.end ( ) ) - 1 ), std::move ( rightHandSide[rightHandSide.size ( ) - 1] ) ) );
+ return addRule ( std::move ( leftHandSide ), ext::make_pair ( ext::vector < SymbolType > ( std::make_move_iterator ( rightHandSide.begin ( ) ), std::make_move_iterator ( rightHandSide.end ( ) ) - 1 ), std::move ( rightHandSide[rightHandSide.size ( ) - 1] ) ) );
else
return addRule ( std::move ( leftHandSide ), std::move ( rightHandSide ) );
}
@@ -516,7 +516,7 @@ ext::map < SymbolType, ext::set < ext::vector < SymbolType > > > RightLG < Symbo
if ( rhs.template is < ext::vector < SymbolType > > ( ) ) {
res[rule.first].insert ( rhs.template get < ext::vector < SymbolType > > ( ) );
} else {
- const auto & rhsTuple = rhs.template get < std::pair < ext::vector < SymbolType >, SymbolType > > ( );
+ const auto & rhsTuple = rhs.template get < ext::pair < ext::vector < SymbolType >, SymbolType > > ( );
ext::vector < SymbolType > tmp { rhsTuple.first.begin ( ), rhsTuple.first.end ( ) };
tmp.push_back ( rhsTuple.second );
res[rule.first].insert ( std::move ( tmp ) );
@@ -531,7 +531,7 @@ bool RightLG < SymbolType >::removeRawRule ( const SymbolType & leftHandSide, co
if ( rightHandSide.size ( ) == 0 )
return removeRule ( leftHandSide, rightHandSide );
else if ( getNonterminalAlphabet ( ).count ( rightHandSide[rightHandSide.size ( ) - 1] ) )
- return removeRule ( leftHandSide, std::make_pair ( ext::vector < SymbolType > ( rightHandSide.begin ( ), rightHandSide.end ( ) - 1 ), rightHandSide[rightHandSide.size ( ) - 1] ) );
+ return removeRule ( leftHandSide, ext::make_pair ( ext::vector < SymbolType > ( rightHandSide.begin ( ), rightHandSide.end ( ) - 1 ), rightHandSide[rightHandSide.size ( ) - 1] ) );
else
return removeRule ( leftHandSide, rightHandSide );
}
@@ -645,15 +645,15 @@ 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, ext::set < ext::variant < ext::vector < SymbolType >, std::pair < ext::vector < SymbolType >, SymbolType > > > > & rule : grammar.getRules ( ) ) {
- for ( const ext::variant < ext::vector < SymbolType >, std::pair < ext::vector < SymbolType >, SymbolType > > & rhsTmp : rule.second )
+ for ( const std::pair < const SymbolType, ext::set < ext::variant < ext::vector < SymbolType >, ext::pair < ext::vector < SymbolType >, SymbolType > > > > & rule : grammar.getRules ( ) ) {
+ for ( const ext::variant < ext::vector < SymbolType >, ext::pair < ext::vector < SymbolType >, SymbolType > > & rhsTmp : rule.second )
if ( rhsTmp.template is < ext::vector < SymbolType > > ( ) ) {
const ext::vector < SymbolType > & rhs = rhsTmp.template get < ext::vector < SymbolType > > ( );
if ( std::find ( rhs.begin ( ), rhs.end ( ), symbol ) != rhs.end ( ) )
return true;
} else {
- const ext::vector < SymbolType > & rhs = rhsTmp.template get < std::pair < ext::vector < SymbolType >, SymbolType > > ( ).first;
+ const ext::vector < SymbolType > & rhs = rhsTmp.template get < ext::pair < ext::vector < SymbolType >, SymbolType > > ( ).first;
if ( std::find ( rhs.begin ( ), rhs.end ( ), symbol ) != rhs.end ( ) )
return true;
@@ -704,13 +704,13 @@ 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, ext::set < ext::variant < ext::vector < SymbolType >, std::pair < ext::vector < SymbolType >, SymbolType > > > > & rule : grammar.getRules ( ) ) {
+ for ( const std::pair < const SymbolType, ext::set < ext::variant < ext::vector < SymbolType >, ext::pair < ext::vector < SymbolType >, SymbolType > > > > & rule : grammar.getRules ( ) ) {
if ( rule.first == symbol )
return true;
- for ( const ext::variant < ext::vector < SymbolType >, std::pair < ext::vector < SymbolType >, SymbolType > > & rhsTmp : rule.second )
- if ( rhsTmp.template is < std::pair < ext::vector < SymbolType >, SymbolType > > ( ) ) {
- const std::pair < ext::vector < SymbolType >, SymbolType > & rhs = rhsTmp.template get < std::pair < ext::vector < SymbolType >, SymbolType > > ( );
+ for ( const ext::variant < ext::vector < SymbolType >, ext::pair < ext::vector < SymbolType >, SymbolType > > & rhsTmp : rule.second )
+ if ( rhsTmp.template is < ext::pair < ext::vector < SymbolType >, SymbolType > > ( ) ) {
+ const ext::pair < ext::vector < SymbolType >, SymbolType > & rhs = rhsTmp.template get < ext::pair < ext::vector < SymbolType >, SymbolType > > ( );
if ( rhs.second == symbol )
return true;
diff --git a/alib2data/src/grammar/Regular/RightRG.h b/alib2data/src/grammar/Regular/RightRG.h
index 8ff70ae0976d03fb4918b859640ac2c31f5a1807..fd95f85aff59b6e7ffd7b05d944cd45b16cf80a7 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.
*/
- ext::map < SymbolType, ext::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > rules;
+ ext::map < SymbolType, ext::set < ext::variant < SymbolType, ext::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, ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rightHandSide );
+ bool addRule ( SymbolType leftHandSide, ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > rightHandSide );
/**
* \brief Add a new rule of a grammar.
@@ -139,7 +139,7 @@ public:
*
* \returns true if the rule was indeed added, false othervise
*/
- bool addRule ( SymbolType leftHandSide, std::pair < SymbolType, SymbolType > rightHandSide );
+ bool addRule ( SymbolType leftHandSide, ext::pair < SymbolType, SymbolType > rightHandSide );
/**
* \brief Add new rules 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, ext::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > rightHandSide );
+ void addRules ( SymbolType leftHandSide, ext::set < ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > > rightHandSide );
/**
* Get rules of the grammar.
*
* \returns rules of the grammar
*/
- const ext::map < SymbolType, ext::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & getRules ( ) const;
+ const ext::map < SymbolType, ext::set < ext::variant < SymbolType, ext::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 ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rightHandSide );
+ bool removeRule ( const SymbolType & leftHandSide, const ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > & rightHandSide );
/**
* Remove a rule of a grammar in form of A -> a, where A \in N and a \in T.
@@ -186,7 +186,7 @@ public:
*
* \returns true if the rule was indeed removed, false othervise
*/
- bool removeRule ( const SymbolType & leftHandSide, const std::pair < SymbolType, SymbolType > & rightHandSide );
+ bool removeRule ( const SymbolType & leftHandSide, const ext::pair < SymbolType, SymbolType > & rightHandSide );
/**
* Add a new rule of a grammar in form of A -> Ba or A -> a, where A, B \in N and a \in T as stored in combination of leftHandSide and rightHandSide represented as vector of symbols.
@@ -401,10 +401,10 @@ public:
RightRG < > * res = new RightRG < > ( std::move ( nonterminals ), std::move ( terminals ), std::move ( initialSymbol ) );
- for ( std::pair < SymbolType, ext::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > && rule : ext::make_moveable_map ( rules ) ) {
+ for ( std::pair < SymbolType, ext::set < ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > > > && rule : ext::make_moveable_map ( rules ) ) {
- ext::set < ext::variant < DefaultSymbolType, std::pair < DefaultSymbolType, DefaultSymbolType > > > rhs;
- for ( ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > && target : ext::make_moveable_set ( rule.second ) )
+ ext::set < ext::variant < DefaultSymbolType, ext::pair < DefaultSymbolType, DefaultSymbolType > > > rhs;
+ for ( ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > && target : ext::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, ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rightHandSide ) {
+bool RightRG < SymbolType >::addRule ( SymbolType leftHandSide, ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > rightHandSide ) {
if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
throw GrammarException ( "Rule must rewrite nonterminal symbol" );
@@ -447,7 +447,7 @@ bool RightRG < SymbolType >::addRule ( SymbolType leftHandSide, ext::variant < S
if ( !getTerminalAlphabet ( ).count ( rhs ) )
throw GrammarException ( "Rule must rewrite to terminal symbol" );
} else {
- const std::pair < SymbolType, SymbolType > & rhs = rightHandSide.template get < std::pair < SymbolType, SymbolType > > ( );
+ const ext::pair < SymbolType, SymbolType > & rhs = rightHandSide.template get < ext::pair < SymbolType, SymbolType > > ( );
if ( !getTerminalAlphabet ( ).count ( rhs.first ) || !getNonterminalAlphabet ( ).count ( rhs.second ) )
throw GrammarException ( "Rule must rewrite to terminal symbol followed by nonterminal symbol" );
@@ -458,31 +458,31 @@ bool RightRG < SymbolType >::addRule ( SymbolType leftHandSide, ext::variant < S
template < class SymbolType >
bool RightRG < SymbolType >::addRule ( SymbolType leftHandSide, SymbolType rightHandSide ) {
- ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( std::move ( rightHandSide ) );
+ ext::variant < SymbolType, ext::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 ) {
- ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( std::move ( rightHandSide ) );
+bool RightRG < SymbolType >::addRule ( SymbolType leftHandSide, ext::pair < SymbolType, SymbolType > rightHandSide ) {
+ ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > rhs ( std::move ( rightHandSide ) );
return addRule ( std::move ( leftHandSide ), std::move ( rhs ) );
}
template < class SymbolType >
-void RightRG < SymbolType >::addRules ( SymbolType leftHandSide, ext::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > rightHandSide ) {
+void RightRG < SymbolType >::addRules ( SymbolType leftHandSide, ext::set < ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > > rightHandSide ) {
if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
throw GrammarException ( "Rule must rewrite nonterminal symbol" );
- for ( const ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > & element : rightHandSide ) {
+ for ( const ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > & element : rightHandSide ) {
if ( element.template is < SymbolType > ( ) ) {
const SymbolType & rhs = element.template get < SymbolType > ( );
if ( ! getTerminalAlphabet ( ).count ( rhs ) )
throw GrammarException ( "Rule must rewrite to terminal symbol" );
} else {
- const std::pair < SymbolType, SymbolType > & rhs = element.template get < std::pair < SymbolType, SymbolType > > ( );
+ const ext::pair < SymbolType, SymbolType > & rhs = element.template get < ext::pair < SymbolType, SymbolType > > ( );
if ( ! getTerminalAlphabet ( ).count ( rhs.first ) || ! getNonterminalAlphabet ( ).count ( rhs.second ) )
throw GrammarException ( "Rule must rewrite to terminal symbol followed by nonterminal symbol" );
@@ -493,25 +493,25 @@ void RightRG < SymbolType >::addRules ( SymbolType leftHandSide, ext::set < ext:
}
template < class SymbolType >
-const ext::map < SymbolType, ext::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & RightRG < SymbolType >::getRules ( ) const {
+const ext::map < SymbolType, ext::set < ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > > > & RightRG < SymbolType >::getRules ( ) const {
return rules;
}
template < class SymbolType >
-bool RightRG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rightHandSide ) {
+bool RightRG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > & rightHandSide ) {
return rules[leftHandSide].erase ( rightHandSide );
}
template < class SymbolType >
bool RightRG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const SymbolType & rightHandSide ) {
- ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( rightHandSide );
+ ext::variant < SymbolType, ext::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 ) {
- ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs ( rightHandSide );
+bool RightRG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const ext::pair < SymbolType, SymbolType > & rightHandSide ) {
+ ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > rhs ( rightHandSide );
return removeRule ( leftHandSide, rhs );
}
@@ -527,7 +527,7 @@ bool RightRG < SymbolType >::addRawRule ( SymbolType leftHandSide, ext::vector <
} else if ( rightHandSide.size ( ) == 1 ) {
return addRule ( std::move ( leftHandSide ), std::move ( rightHandSide[0] ) );
} else if ( rightHandSide.size ( ) == 2 ) {
- return addRule ( std::move ( leftHandSide ), std::make_pair ( std::move ( rightHandSide[0] ), std::move ( rightHandSide[1] ) ) );
+ return addRule ( std::move ( leftHandSide ), ext::make_pair ( std::move ( rightHandSide[0] ), std::move ( rightHandSide[1] ) ) );
} else {
throw GrammarException ( "Invalid right hand side" );
}
@@ -543,7 +543,7 @@ ext::map < SymbolType, ext::set < ext::vector < SymbolType > > > RightRG < Symbo
ext::vector < SymbolType > tmp { rhs.template get < SymbolType > ( ) };
res[rule.first].insert ( std::move ( tmp ) );
} else {
- const auto & rhsPair = rhs.template get < std::pair < SymbolType, SymbolType > > ( );
+ const auto & rhsPair = rhs.template get < ext::pair < SymbolType, SymbolType > > ( );
ext::vector < SymbolType > tmp { rhsPair.first, rhsPair.second };
res[rule.first].insert ( std::move ( tmp ) );
}
@@ -566,7 +566,7 @@ bool RightRG < SymbolType >::removeRawRule ( const SymbolType & leftHandSide, co
} else if ( rightHandSide.size ( ) == 1 ) {
return removeRule ( leftHandSide, rightHandSide[0] );
} else if ( rightHandSide.size ( ) == 2 ) {
- return removeRule ( leftHandSide, std::make_pair ( rightHandSide[0], rightHandSide[1] ) );
+ return removeRule ( leftHandSide, ext::make_pair ( rightHandSide[0], rightHandSide[1] ) );
} else {
throw GrammarException ( "Invalid right hand side" );
}
@@ -632,7 +632,7 @@ RightRG < SymbolType > RightRG < SymbolType >::parse ( ext::deque < sax::Token >
template < class SymbolType >
void RightRG < SymbolType >::parseRule ( ext::deque < sax::Token >::iterator & input, RightRG & grammar ) {
SymbolType lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS < SymbolType > ( input );
- ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs = GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS < SymbolType > ( input );
+ ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > rhs = GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS < SymbolType > ( input );
grammar.addRule ( std::move ( lhs ), std::move ( rhs ) );
}
@@ -694,9 +694,9 @@ 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, ext::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 ) )
+ for ( const std::pair < const SymbolType, ext::set < ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > > > & rule : grammar.getRules ( ) )
+ for ( const ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > & rhs : rule.second )
+ if ( ( rhs.template is < SymbolType > ( ) && ( rhs.template get < SymbolType > ( ) == symbol ) ) || ( rhs.template get < ext::pair < SymbolType, SymbolType > > ( ).first == symbol ) )
return true;
return false;
@@ -742,12 +742,12 @@ 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, ext::set < ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & rule : grammar.getRules ( ) ) {
+ for ( const std::pair < const SymbolType, ext::set < ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > > > & rule : grammar.getRules ( ) ) {
if ( rule.first == symbol )
return true;
- for ( const ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rhs : rule.second )
- if ( rhs.template get < std::pair < SymbolType, SymbolType > > ( ).second == symbol )
+ for ( const ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > & rhs : rule.second )
+ if ( rhs.template get < ext::pair < SymbolType, SymbolType > > ( ).second == symbol )
return true;
}
diff --git a/alib2data/src/grammar/common/GrammarFromXMLParser.h b/alib2data/src/grammar/common/GrammarFromXMLParser.h
index 6fb40612f873c195a292634eaf08e7c4ba4be91b..c882a901bf6ff6c90c5aac56a06b9c732d1522f4 100644
--- a/alib2data/src/grammar/common/GrammarFromXMLParser.h
+++ b/alib2data/src/grammar/common/GrammarFromXMLParser.h
@@ -56,11 +56,11 @@ public:
template < class SymbolType >
static SymbolType parseRuleSingleSymbolLHS(ext::deque<sax::Token>::iterator& input);
template < class SymbolType >
- static std::pair<SymbolType, ext::vector<SymbolType>> parseRuleGNFRHS(ext::deque<sax::Token>::iterator& input);
+ static ext::pair<SymbolType, ext::vector<SymbolType>> parseRuleGNFRHS(ext::deque<sax::Token>::iterator& input);
template < class SymbolType >
static ext::vector<SymbolType> parseRuleRHS(ext::deque<sax::Token>::iterator& input);
template < class SymbolType >
- static ext::variant<SymbolType, std::pair<SymbolType, SymbolType>> parseRuleOneOrTwoSymbolsRHS(ext::deque<sax::Token>::iterator& input);
+ static ext::variant<SymbolType, ext::pair<SymbolType, SymbolType>> parseRuleOneOrTwoSymbolsRHS(ext::deque<sax::Token>::iterator& input);
template<class T>
static void parseRules(ext::deque<sax::Token>::iterator& input, T& grammar);
@@ -147,7 +147,7 @@ ext::vector<SymbolType> GrammarFromXMLParser::parseRuleRContext(ext::deque<sax::
}
template < class SymbolType >
-std::pair<SymbolType, ext::vector<SymbolType>> GrammarFromXMLParser::parseRuleGNFRHS(ext::deque<sax::Token>::iterator& input) {
+ext::pair<SymbolType, ext::vector<SymbolType>> GrammarFromXMLParser::parseRuleGNFRHS(ext::deque<sax::Token>::iterator& input) {
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "rhs");
SymbolType first = alib::xmlApi<SymbolType>::parse(input);
ext::vector<SymbolType> second;
@@ -155,7 +155,7 @@ std::pair<SymbolType, ext::vector<SymbolType>> GrammarFromXMLParser::parseRuleGN
second.push_back(alib::xmlApi<SymbolType>::parse(input));
}
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "rhs");
- return std::make_pair(std::move(first), std::move(second));
+ return ext::make_pair(std::move(first), std::move(second));
}
template < class SymbolType >
@@ -173,16 +173,16 @@ ext::vector<SymbolType> GrammarFromXMLParser::parseRuleRHS(ext::deque<sax::Token
}
template < class SymbolType >
-ext::variant<SymbolType, std::pair<SymbolType, SymbolType>> GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS(ext::deque<sax::Token>::iterator& input) {
+ext::variant<SymbolType, ext::pair<SymbolType, SymbolType>> GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS(ext::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 ext::variant<SymbolType, std::pair<SymbolType, SymbolType>>(std::make_pair(std::move(first), std::move(second)));
+ return ext::variant<SymbolType, ext::pair<SymbolType, SymbolType>>(ext::make_pair(std::move(first), std::move(second)));
} else {
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "rhs");
- return ext::variant<SymbolType, std::pair<SymbolType, SymbolType>>(std::move(first));
+ return ext::variant<SymbolType, ext::pair<SymbolType, SymbolType>>(std::move(first));
}
}
diff --git a/alib2data/src/grammar/common/GrammarNormalize.h b/alib2data/src/grammar/common/GrammarNormalize.h
index 6e43c32e8e6bcfe3a0cb1883262499696f35b265..ed9f1a619951de1d31747d0d1fbbc5819b5a0c29 100644
--- a/alib2data/src/grammar/common/GrammarNormalize.h
+++ b/alib2data/src/grammar/common/GrammarNormalize.h
@@ -23,16 +23,16 @@ namespace grammar {
class GrammarNormalize {
public:
template < class SymbolType >
- static std::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > normalizeRHS ( std::pair < SymbolType, ext::vector < SymbolType > > && symbol );
+ static ext::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > normalizeRHS ( ext::pair < SymbolType, ext::vector < SymbolType > > && symbol );
template < class SymbolType >
- static ext::variant < DefaultSymbolType, std::pair < DefaultSymbolType, DefaultSymbolType > > normalizeRHS ( ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > && symbol );
+ static ext::variant < DefaultSymbolType, ext::pair < DefaultSymbolType, DefaultSymbolType > > normalizeRHS ( ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > && symbol );
template < class SymbolType >
- static ext::variant < ext::vector < DefaultSymbolType >, std::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > > normalizeRHS ( ext::variant < ext::vector < SymbolType >, std::pair < SymbolType, ext::vector < SymbolType > > > && symbol );
+ static ext::variant < ext::vector < DefaultSymbolType >, ext::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > > normalizeRHS ( ext::variant < ext::vector < SymbolType >, ext::pair < SymbolType, ext::vector < SymbolType > > > && symbol );
template < class SymbolType >
- static ext::variant < ext::vector < DefaultSymbolType >, std::pair < ext::vector < DefaultSymbolType >, DefaultSymbolType > > normalizeRHS ( ext::variant < ext::vector < SymbolType >, std::pair < ext::vector < SymbolType >, SymbolType > > && symbol );
+ static ext::variant < ext::vector < DefaultSymbolType >, ext::pair < ext::vector < DefaultSymbolType >, DefaultSymbolType > > normalizeRHS ( ext::variant < ext::vector < SymbolType >, ext::pair < ext::vector < SymbolType >, SymbolType > > && symbol );
template < class SymbolType >
static ext::variant < ext::vector < DefaultSymbolType >, ext::tuple < ext::vector < DefaultSymbolType >, DefaultSymbolType, ext::vector < DefaultSymbolType > > > normalizeRHS ( ext::variant < ext::vector < SymbolType >, ext::tuple < ext::vector < SymbolType >, SymbolType, ext::vector < SymbolType > > > && symbols );
@@ -40,37 +40,37 @@ public:
};
template < class SymbolType >
-std::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > GrammarNormalize::normalizeRHS ( std::pair < SymbolType, ext::vector < SymbolType > > && symbol ) {
- return std::make_pair ( alphabet::SymbolNormalize::normalizeSymbol ( std::move ( symbol.first ) ), alphabet::SymbolNormalize::normalizeSymbols ( std::move ( symbol.second ) ) );
+ext::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > GrammarNormalize::normalizeRHS ( ext::pair < SymbolType, ext::vector < SymbolType > > && symbol ) {
+ return ext::make_pair ( alphabet::SymbolNormalize::normalizeSymbol ( std::move ( symbol.first ) ), alphabet::SymbolNormalize::normalizeSymbols ( std::move ( symbol.second ) ) );
}
template < class SymbolType >
-ext::variant < DefaultSymbolType, std::pair < DefaultSymbolType, DefaultSymbolType > > GrammarNormalize::normalizeRHS ( ext::variant < SymbolType, std::pair < SymbolType, SymbolType > > && symbol ) {
+ext::variant < DefaultSymbolType, ext::pair < DefaultSymbolType, DefaultSymbolType > > GrammarNormalize::normalizeRHS ( ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > && symbol ) {
if ( symbol.template is < SymbolType > ( ) ) {
- return ext::variant < DefaultSymbolType, std::pair < DefaultSymbolType, DefaultSymbolType > > ( alphabet::SymbolNormalize::normalizeSymbol ( std::move ( symbol.template get < SymbolType > ( ) ) ) );
+ return ext::variant < DefaultSymbolType, ext::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 ext::variant < DefaultSymbolType, std::pair < DefaultSymbolType, DefaultSymbolType > > ( std::make_pair ( alphabet::SymbolNormalize::normalizeSymbol ( std::move ( inner.first ) ), alphabet::SymbolNormalize::normalizeSymbol ( std::move ( inner.second ) ) ) );
+ ext::pair < SymbolType, SymbolType > & inner = symbol.template get < ext::pair < SymbolType, SymbolType > > ( );
+ return ext::variant < DefaultSymbolType, ext::pair < DefaultSymbolType, DefaultSymbolType > > ( ext::make_pair ( alphabet::SymbolNormalize::normalizeSymbol ( std::move ( inner.first ) ), alphabet::SymbolNormalize::normalizeSymbol ( std::move ( inner.second ) ) ) );
}
}
template < class SymbolType >
-ext::variant < ext::vector < DefaultSymbolType >, std::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > > GrammarNormalize::normalizeRHS ( ext::variant < ext::vector < SymbolType >, std::pair < SymbolType, ext::vector < SymbolType > > > && symbol ) {
+ext::variant < ext::vector < DefaultSymbolType >, ext::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > > GrammarNormalize::normalizeRHS ( ext::variant < ext::vector < SymbolType >, ext::pair < SymbolType, ext::vector < SymbolType > > > && symbol ) {
if ( symbol.template is < ext::vector < SymbolType > > ( ) ) {
- return ext::variant < ext::vector < DefaultSymbolType >, std::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > > ( alphabet::SymbolNormalize::normalizeSymbols ( std::move ( symbol.template get < ext::vector < SymbolType > > ( ) ) ) );
+ return ext::variant < ext::vector < DefaultSymbolType >, ext::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > > ( alphabet::SymbolNormalize::normalizeSymbols ( std::move ( symbol.template get < ext::vector < SymbolType > > ( ) ) ) );
} else {
- std::pair < SymbolType, ext::vector < SymbolType > > & inner = symbol.template get < std::pair < SymbolType, ext::vector < SymbolType > > > ( );
- return ext::variant < ext::vector < DefaultSymbolType >, std::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > > ( std::make_pair ( alphabet::SymbolNormalize::normalizeSymbol ( std::move ( inner.first ) ), alphabet::SymbolNormalize::normalizeSymbols ( std::move ( inner.second ) ) ) );
+ ext::pair < SymbolType, ext::vector < SymbolType > > & inner = symbol.template get < ext::pair < SymbolType, ext::vector < SymbolType > > > ( );
+ return ext::variant < ext::vector < DefaultSymbolType >, ext::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > > ( ext::make_pair ( alphabet::SymbolNormalize::normalizeSymbol ( std::move ( inner.first ) ), alphabet::SymbolNormalize::normalizeSymbols ( std::move ( inner.second ) ) ) );
}
}
template < class SymbolType >
-ext::variant < ext::vector < DefaultSymbolType >, std::pair < ext::vector < DefaultSymbolType >, DefaultSymbolType > > GrammarNormalize::normalizeRHS ( ext::variant < ext::vector < SymbolType >, std::pair < ext::vector < SymbolType >, SymbolType > > && symbol ) {
+ext::variant < ext::vector < DefaultSymbolType >, ext::pair < ext::vector < DefaultSymbolType >, DefaultSymbolType > > GrammarNormalize::normalizeRHS ( ext::variant < ext::vector < SymbolType >, ext::pair < ext::vector < SymbolType >, SymbolType > > && symbol ) {
if ( symbol.template is < ext::vector < SymbolType > > ( ) ) {
- return ext::variant < ext::vector < DefaultSymbolType >, std::pair < ext::vector < DefaultSymbolType >, DefaultSymbolType > > ( alphabet::SymbolNormalize::normalizeSymbols ( std::move ( symbol.template get < ext::vector < SymbolType > > ( ) ) ) );
+ return ext::variant < ext::vector < DefaultSymbolType >, ext::pair < ext::vector < DefaultSymbolType >, DefaultSymbolType > > ( alphabet::SymbolNormalize::normalizeSymbols ( std::move ( symbol.template get < ext::vector < SymbolType > > ( ) ) ) );
} else {
- std::pair < ext::vector < SymbolType >, SymbolType > & inner = symbol.template get < std::pair < ext::vector < SymbolType >, SymbolType > > ( );
- return ext::variant < ext::vector < DefaultSymbolType >, std::pair < ext::vector < DefaultSymbolType >, DefaultSymbolType > > ( std::make_pair ( alphabet::SymbolNormalize::normalizeSymbols ( std::move ( inner.first ) ), alphabet::SymbolNormalize::normalizeSymbol ( std::move ( inner.second ) ) ) );
+ ext::pair < ext::vector < SymbolType >, SymbolType > & inner = symbol.template get < ext::pair < ext::vector < SymbolType >, SymbolType > > ( );
+ return ext::variant < ext::vector < DefaultSymbolType >, ext::pair < ext::vector < DefaultSymbolType >, DefaultSymbolType > > ( ext::make_pair ( alphabet::SymbolNormalize::normalizeSymbols ( std::move ( inner.first ) ), alphabet::SymbolNormalize::normalizeSymbol ( std::move ( inner.second ) ) ) );
}
}
diff --git a/alib2data/src/grammar/common/GrammarToXMLComposer.h b/alib2data/src/grammar/common/GrammarToXMLComposer.h
index aa4a10465c3a88d51937b125f2527712733e9048..7702b168b84eb333f1a724074c355132dedffac4 100644
--- a/alib2data/src/grammar/common/GrammarToXMLComposer.h
+++ b/alib2data/src/grammar/common/GrammarToXMLComposer.h
@@ -54,13 +54,13 @@ public:
template < class SymbolType >
static void composeRuleRHS(ext::deque<sax::Token>& out, const ext::vector<SymbolType>& symbols);
template < class SymbolType >
- static void composeRuleOneOrTwoSymbolsRHS(ext::deque<sax::Token>& out, const ext::variant<SymbolType, std::pair<SymbolType, SymbolType>>& symbols);
+ static void composeRuleOneOrTwoSymbolsRHS(ext::deque<sax::Token>& out, const ext::variant<SymbolType, ext::pair<SymbolType, SymbolType>>& symbols);
template < class SymbolType >
- static void composeRuleGNFRHS(ext::deque<sax::Token>& out, const std::pair<SymbolType, ext::vector<SymbolType>>& symbols);
+ static void composeRuleGNFRHS(ext::deque<sax::Token>& out, const ext::pair<SymbolType, ext::vector<SymbolType>>& symbols);
template < class SymbolType >
- static void composeRuleLeftLGRHS(ext::deque<sax::Token>& out, const ext::variant<ext::vector<SymbolType>, std::pair<SymbolType, ext::vector<SymbolType>>>& symbols);
+ static void composeRuleLeftLGRHS(ext::deque<sax::Token>& out, const ext::variant<ext::vector<SymbolType>, ext::pair<SymbolType, ext::vector<SymbolType>>>& symbols);
template < class SymbolType >
- static void composeRuleRightLGRHS(ext::deque<sax::Token>& out, const ext::variant<ext::vector<SymbolType>, std::pair<ext::vector<SymbolType>, SymbolType>>& symbols);
+ static void composeRuleRightLGRHS(ext::deque<sax::Token>& out, const ext::variant<ext::vector<SymbolType>, ext::pair<ext::vector<SymbolType>, SymbolType>>& symbols);
template < class SymbolType >
static void composeRuleLGRHS(ext::deque<sax::Token>& out, const ext::variant<ext::vector<SymbolType>, ext::tuple<ext::vector<SymbolType>, SymbolType, ext::vector<SymbolType>>>& symbols);
};
@@ -146,12 +146,12 @@ void GrammarToXMLComposer::composeRuleRHS(ext::deque<sax::Token>& out, const ext
}
template < class SymbolType >
-void GrammarToXMLComposer::composeRuleOneOrTwoSymbolsRHS(ext::deque<sax::Token>& out, const ext::variant<SymbolType, std::pair<SymbolType, SymbolType>>& symbols) {
+void GrammarToXMLComposer::composeRuleOneOrTwoSymbolsRHS(ext::deque<sax::Token>& out, const ext::variant<SymbolType, ext::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>());
} else {
- const std::pair<SymbolType, SymbolType>& rhs = symbols.template get<std::pair<SymbolType, SymbolType>>();
+ const ext::pair<SymbolType, SymbolType>& rhs = symbols.template get<ext::pair<SymbolType, SymbolType>>();
alib::xmlApi<SymbolType>::compose(out, rhs.first);
alib::xmlApi<SymbolType>::compose(out, rhs.second);
}
@@ -159,7 +159,7 @@ void GrammarToXMLComposer::composeRuleOneOrTwoSymbolsRHS(ext::deque<sax::Token>&
}
template < class SymbolType >
-void GrammarToXMLComposer::composeRuleGNFRHS(ext::deque<sax::Token>& out, const std::pair<SymbolType, ext::vector<SymbolType>>& symbols) {
+void GrammarToXMLComposer::composeRuleGNFRHS(ext::deque<sax::Token>& out, const ext::pair<SymbolType, ext::vector<SymbolType>>& symbols) {
out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
alib::xmlApi<SymbolType>::compose(out, symbols.first);
@@ -196,7 +196,7 @@ void GrammarToXMLComposer::composeRuleLGRHS(ext::deque<sax::Token>& out, const e
}
template < class SymbolType >
-void GrammarToXMLComposer::composeRuleLeftLGRHS(ext::deque<sax::Token>& out, const ext::variant<ext::vector<SymbolType>, std::pair<SymbolType, ext::vector<SymbolType>>>& symbols) {
+void GrammarToXMLComposer::composeRuleLeftLGRHS(ext::deque<sax::Token>& out, const ext::variant<ext::vector<SymbolType>, ext::pair<SymbolType, ext::vector<SymbolType>>>& symbols) {
out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
if(symbols.template is<ext::vector<SymbolType>>()) {
const ext::vector<SymbolType>& rhs = symbols.template get<ext::vector<SymbolType>>();
@@ -207,7 +207,7 @@ void GrammarToXMLComposer::composeRuleLeftLGRHS(ext::deque<sax::Token>& out, con
alib::xmlApi<SymbolType>::compose(out, symbol);
}
} else {
- const std::pair<SymbolType, ext::vector<SymbolType>>& rhs = symbols.template get<std::pair<SymbolType, ext::vector<SymbolType>>>();
+ const ext::pair<SymbolType, ext::vector<SymbolType>>& rhs = symbols.template get<ext::pair<SymbolType, ext::vector<SymbolType>>>();
alib::xmlApi<SymbolType>::compose(out, rhs.first);
for (const auto& symbol : rhs.second) {
alib::xmlApi<SymbolType>::compose(out, symbol);
@@ -217,7 +217,7 @@ void GrammarToXMLComposer::composeRuleLeftLGRHS(ext::deque<sax::Token>& out, con
}
template < class SymbolType >
-void GrammarToXMLComposer::composeRuleRightLGRHS(ext::deque<sax::Token>& out, const ext::variant<ext::vector<SymbolType>, std::pair<ext::vector<SymbolType>, SymbolType>>& symbols) {
+void GrammarToXMLComposer::composeRuleRightLGRHS(ext::deque<sax::Token>& out, const ext::variant<ext::vector<SymbolType>, ext::pair<ext::vector<SymbolType>, SymbolType>>& symbols) {
out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
if(symbols.template is<ext::vector<SymbolType>>()) {
const ext::vector<SymbolType>& rhs = symbols.template get<ext::vector<SymbolType>>();
@@ -230,7 +230,7 @@ void GrammarToXMLComposer::composeRuleRightLGRHS(ext::deque<sax::Token>& out, co
}
}
} else {
- const std::pair<ext::vector<SymbolType>, SymbolType>& rhs = symbols.template get<std::pair<ext::vector<SymbolType>, SymbolType>>();
+ const ext::pair<ext::vector<SymbolType>, SymbolType>& rhs = symbols.template get<ext::pair<ext::vector<SymbolType>, SymbolType>>();
for (const auto& symbol : rhs.first) {
alib::xmlApi<SymbolType>::compose(out, symbol);
}
diff --git a/alib2data/test-src/grammar/GrammarTest.cpp b/alib2data/test-src/grammar/GrammarTest.cpp
index ebf465ce44bcc3c96cac843c7b5ac17c660bfcc9..ae6fcbed6a93823aacc14fbe5c8160918ee5a6e2 100644
--- a/alib2data/test-src/grammar/GrammarTest.cpp
+++ b/alib2data/test-src/grammar/GrammarTest.cpp
@@ -101,8 +101,8 @@ void GrammarTest::testRegularParser() {
grammar.addTerminalSymbol(DefaultSymbolType("a"));
grammar.addTerminalSymbol(DefaultSymbolType("b"));
- grammar.addRule(DefaultSymbolType(1), std::make_pair(DefaultSymbolType("a"), DefaultSymbolType(2)));
- grammar.addRule(DefaultSymbolType(2), std::make_pair(DefaultSymbolType("b"), DefaultSymbolType(3)));
+ grammar.addRule(DefaultSymbolType(1), ext::make_pair(DefaultSymbolType("a"), DefaultSymbolType(2)));
+ grammar.addRule(DefaultSymbolType(2), ext::make_pair(DefaultSymbolType("b"), DefaultSymbolType(3)));
CPPUNIT_ASSERT( grammar == grammar );
{
@@ -127,10 +127,10 @@ void GrammarTest::testRegularParser() {
grammar.addTerminalSymbol(DefaultSymbolType("a"));
grammar.addTerminalSymbol(DefaultSymbolType("b"));
- grammar.addRule(DefaultSymbolType(1), std::make_pair(ext::vector<DefaultSymbolType> {DefaultSymbolType("a")}, DefaultSymbolType(2)));
- grammar.addRule(DefaultSymbolType(2), std::make_pair(ext::vector<DefaultSymbolType> {DefaultSymbolType("b")}, DefaultSymbolType(3)));
- grammar.addRule(DefaultSymbolType(1), std::make_pair(ext::vector<DefaultSymbolType> {}, DefaultSymbolType(3)));
- grammar.addRule(DefaultSymbolType(1), std::make_pair(ext::vector<DefaultSymbolType> {DefaultSymbolType("a"), DefaultSymbolType("a"), DefaultSymbolType("a")}, DefaultSymbolType(2)));
+ grammar.addRule(DefaultSymbolType(1), ext::make_pair(ext::vector<DefaultSymbolType> {DefaultSymbolType("a")}, DefaultSymbolType(2)));
+ grammar.addRule(DefaultSymbolType(2), ext::make_pair(ext::vector<DefaultSymbolType> {DefaultSymbolType("b")}, DefaultSymbolType(3)));
+ grammar.addRule(DefaultSymbolType(1), ext::make_pair(ext::vector<DefaultSymbolType> {}, DefaultSymbolType(3)));
+ grammar.addRule(DefaultSymbolType(1), ext::make_pair(ext::vector<DefaultSymbolType> {DefaultSymbolType("a"), DefaultSymbolType("a"), DefaultSymbolType("a")}, DefaultSymbolType(2)));
CPPUNIT_ASSERT( grammar == grammar );
{
@@ -243,8 +243,8 @@ void GrammarTest::testContextFreeParser() {
grammar.addTerminalSymbol(DefaultSymbolType("b"));
grammar.setGeneratesEpsilon(true);
- grammar.addRule(DefaultSymbolType(1), std::make_pair(DefaultSymbolType(3), DefaultSymbolType(2)));
- grammar.addRule(DefaultSymbolType(2), std::make_pair(DefaultSymbolType(3), DefaultSymbolType(3)));
+ grammar.addRule(DefaultSymbolType(1), ext::make_pair(DefaultSymbolType(3), DefaultSymbolType(2)));
+ grammar.addRule(DefaultSymbolType(2), ext::make_pair(DefaultSymbolType(3), DefaultSymbolType(3)));
grammar.addRule(DefaultSymbolType(3), DefaultSymbolType("a"));
grammar.addRule(DefaultSymbolType(1), DefaultSymbolType("a"));
@@ -271,10 +271,10 @@ void GrammarTest::testContextFreeParser() {
grammar.addTerminalSymbol(DefaultSymbolType("b"));
grammar.setGeneratesEpsilon(true);
- grammar.addRule(DefaultSymbolType(1), std::make_pair(DefaultSymbolType("a"), ext::vector<DefaultSymbolType> {DefaultSymbolType(2)}));
- grammar.addRule(DefaultSymbolType(2), std::make_pair(DefaultSymbolType("b"), ext::vector<DefaultSymbolType> {DefaultSymbolType(3)}));
- grammar.addRule(DefaultSymbolType(3), std::make_pair(DefaultSymbolType("a"), ext::vector<DefaultSymbolType> {}));
- grammar.addRule(DefaultSymbolType(1), std::make_pair(DefaultSymbolType("a"), ext::vector<DefaultSymbolType> {}));
+ grammar.addRule(DefaultSymbolType(1), ext::make_pair(DefaultSymbolType("a"), ext::vector<DefaultSymbolType> {DefaultSymbolType(2)}));
+ grammar.addRule(DefaultSymbolType(2), ext::make_pair(DefaultSymbolType("b"), ext::vector<DefaultSymbolType> {DefaultSymbolType(3)}));
+ grammar.addRule(DefaultSymbolType(3), ext::make_pair(DefaultSymbolType("a"), ext::vector<DefaultSymbolType> {}));
+ grammar.addRule(DefaultSymbolType(1), ext::make_pair(DefaultSymbolType("a"), ext::vector<DefaultSymbolType> {}));
CPPUNIT_ASSERT( grammar == grammar );
{
diff --git a/alib2data_experimental/src/grammar/parsing/LRParserTypes.h b/alib2data_experimental/src/grammar/parsing/LRParserTypes.h
index f4557bdfd7fb19fd49bb3c1f9b331769f7a842f2..5a192d264d71ff56a8c04eac0d597cf1a1bec8e6 100644
--- a/alib2data_experimental/src/grammar/parsing/LRParserTypes.h
+++ b/alib2data_experimental/src/grammar/parsing/LRParserTypes.h
@@ -26,9 +26,9 @@ enum class LRAction {
Accept
};
-typedef ext::map < DefaultSymbolType, ext::set < std::pair < unsigned, ext::vector < DefaultSymbolType > > > > LR0Items;
-typedef ext::map < std::pair < DefaultStateType, DefaultSymbolType >, std::pair < LRAction, ext::variant < DefaultStateType, std::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > > > > LRActionTable;
-typedef ext::map < std::pair < DefaultStateType, DefaultSymbolType >, DefaultStateType > LRGotoTable;
+typedef ext::map < DefaultSymbolType, ext::set < ext::pair < unsigned, ext::vector < DefaultSymbolType > > > > LR0Items;
+typedef ext::map < ext::pair < DefaultStateType, DefaultSymbolType >, ext::pair < LRAction, ext::variant < DefaultStateType, ext::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > > > > LRActionTable;
+typedef ext::map < ext::pair < DefaultStateType, DefaultSymbolType >, DefaultStateType > LRGotoTable;
} /* namespace parsing */
diff --git a/alib2elgo/src/automaton/properties/efficient/AllEpsilonClosure.h b/alib2elgo/src/automaton/properties/efficient/AllEpsilonClosure.h
index 11ff00cf9c3763ecc35b46e0f08bfa0ede2c5fd9..e247202e1413b267de8c535de895cd88fadbfb93 100644
--- a/alib2elgo/src/automaton/properties/efficient/AllEpsilonClosure.h
+++ b/alib2elgo/src/automaton/properties/efficient/AllEpsilonClosure.h
@@ -133,7 +133,7 @@ ext::map<StateType, ext::set<StateType>> AllEpsilonClosure::allEpsilonClosure( c
ext::set<StateType> nonvisited = fsm.getStates();
ext::map<StateType, ext::set<StateType>> epsilonTransitions;
- for(const std::pair<const std::pair<StateType, regexp::UnboundedRegExpStructure < SymbolType > >, ext::set<StateType> >& transition : fsm.getTransitions() )
+ for(const std::pair<const ext::pair<StateType, regexp::UnboundedRegExpStructure < SymbolType > >, ext::set<StateType> >& transition : fsm.getTransitions() )
if( regexp::properties::RegExpEpsilon::languageContainsEpsilon( transition.first.second ) )
epsilonTransitions[transition.first.first].insert(transition.second.begin(), transition.second.end());
@@ -161,7 +161,7 @@ ext::map<StateType, ext::set<StateType>> AllEpsilonClosure::allEpsilonClosure( c
ext::set<StateType> nonvisited = fsm.getStates();
ext::map<StateType, ext::set<StateType>> epsilonTransitions;
- for(const std::pair<const std::pair<StateType, ext::vector < SymbolType > >, ext::set<StateType> >& transition : fsm.getTransitions() )
+ for(const std::pair<const ext::pair<StateType, ext::vector < SymbolType > >, ext::set<StateType> >& transition : fsm.getTransitions() )
if( transition.first.second.size() == 0 )
epsilonTransitions[transition.first.first].insert(transition.second.begin(), transition.second.end());
diff --git a/alib2elgo/src/automaton/simplify/efficient/EpsilonRemoverIncoming.h b/alib2elgo/src/automaton/simplify/efficient/EpsilonRemoverIncoming.h
index c059896aea787e518feeb11bd743ff2b99378792..5027264142fa859a0b8800b5c1ce9f4c8d648238 100644
--- a/alib2elgo/src/automaton/simplify/efficient/EpsilonRemoverIncoming.h
+++ b/alib2elgo/src/automaton/simplify/efficient/EpsilonRemoverIncoming.h
@@ -68,7 +68,7 @@ automaton::NFA < SymbolType, StateType > EpsilonRemoverIncoming::remove ( const
ext::map < StateType, ext::set < StateType > > closures = automaton::properties::efficient::AllEpsilonClosure::allEpsilonClosure ( origFSM );
- ext::map < std::pair < StateType, SymbolType >, ext::set < StateType > > origTransitions = origFSM.getSymbolTransitions ( );
+ ext::map < ext::pair < StateType, SymbolType >, ext::set < StateType > > origTransitions = origFSM.getSymbolTransitions ( );
/**
* Step 1 from Melichar 2.41
@@ -76,7 +76,7 @@ automaton::NFA < SymbolType, StateType > EpsilonRemoverIncoming::remove ( const
for ( const auto & from : origFSM.getStates ( ) )
for ( const auto & fromClosure : closures [ from ] )
for ( const auto & symbol : origFSM.getInputAlphabet ( ) ) {
- auto transitions = origTransitions.find ( std::make_pair ( fromClosure, symbol ) );
+ auto transitions = origTransitions.find ( ext::make_pair ( fromClosure, symbol ) );
if ( transitions == origTransitions.end ( ) ) continue;
for ( const auto & to : transitions->second )
diff --git a/alib2elgo/src/automaton/simplify/efficient/EpsilonRemoverOutgoing.h b/alib2elgo/src/automaton/simplify/efficient/EpsilonRemoverOutgoing.h
index 7ccbeaaae00915c515ce39cccf454704d0c222b1..38fbac485811b74d3ccb32aaf1f20f4547b93bfa 100644
--- a/alib2elgo/src/automaton/simplify/efficient/EpsilonRemoverOutgoing.h
+++ b/alib2elgo/src/automaton/simplify/efficient/EpsilonRemoverOutgoing.h
@@ -68,9 +68,9 @@ automaton::MultiInitialStateNFA < SymbolType, StateType > EpsilonRemoverOutgoing
ext::map < StateType, ext::set < StateType > > closures = automaton::properties::efficient::AllEpsilonClosure::allEpsilonClosure ( origFSM );
- ext::map < std::pair < StateType, SymbolType >, ext::set < StateType > > transitions = origFSM.getSymbolTransitions ( );
+ ext::map < ext::pair < StateType, SymbolType >, ext::set < StateType > > transitions = origFSM.getSymbolTransitions ( );
- for ( const std::pair < const std::pair < StateType, SymbolType >, ext::set < StateType > > & transition : transitions )
+ for ( const std::pair < const ext::pair < StateType, SymbolType >, ext::set < StateType > > & transition : transitions )
for ( const StateType & to : transition.second )
for ( const StateType & toClosure : closures [ to ] )
fsm.addTransition ( transition.first.first, transition.first.second, toClosure );
diff --git a/alib2std/src/extensions/linear_set.hpp b/alib2std/src/extensions/linear_set.hpp
index dc97b821b36018ef814c18dcd8cc452394057939..e3dda1d76badbfcafe8e9affe97f5496ee959f46 100644
--- a/alib2std/src/extensions/linear_set.hpp
+++ b/alib2std/src/extensions/linear_set.hpp
@@ -125,11 +125,11 @@ public:
}
std::pair<const_iterator,const_iterator> equal_range (const T& val) const {
- return make_pair ( lower_bound ( val ), upper_bound ( val ) );
+ return std::make_pair ( lower_bound ( val ), upper_bound ( val ) );
}
std::pair<iterator,iterator> equal_range (const T& val) {
- return make_pair ( lower_bound ( val ), upper_bound ( val ) );
+ return std::make_pair ( lower_bound ( val ), upper_bound ( val ) );
}
iterator erase (const_iterator position) {
@@ -167,9 +167,9 @@ public:
std::pair<iterator,bool> insert (T&& val) {
const_iterator position = lower_bound ( val );
if ( position != end ( ) && eq ( * position, val ) )
- return make_pair ( position, false );
+ return std::make_pair ( position, false );
else
- return make_pair ( m_data.emplace ( position, std::move ( val ) ), true );
+ return std::make_pair ( m_data.emplace ( position, std::move ( val ) ), true );
}
iterator insert (const_iterator position, const T& val) {
diff --git a/alib2std/src/extensions/map.hpp b/alib2std/src/extensions/map.hpp
index d0d985625cd4d0841d82b19b59dda9d93fa843f2..ac65792b5c3e0192ae29d8a7949afa1ffa4a3d58 100644
--- a/alib2std/src/extensions/map.hpp
+++ b/alib2std/src/extensions/map.hpp
@@ -59,7 +59,7 @@ std::ostream& operator<<(std::ostream& out, const ext::map<T, R, Ts ... >& map)
for(const std::pair<const T, R>& item : map) {
if(!first) out << ", ";
first = false;
- out << item;
+ out << "(" << item.first << ", " << item.second << ")";
}
out << "}";
@@ -72,9 +72,11 @@ struct compare < ext::map < T, R, Ts ... > > {
if(first.size() < second.size()) return -1;
if(first.size() > second.size()) return 1;
- static compare<std::pair<typename std::decay < T >::type, typename std::decay < R >::type >> comp;
+ static compare < typename std::decay < T >::type > compT;
+ static compare < typename std::decay < R >::type > compR;
for(auto iterF = first.begin(), iterS = second.begin(); iterF != first.end(); ++iterF, ++iterS) {
- int res = comp(*iterF, *iterS);
+ int res = compT(iterF->first, iterS->first);
+ if(res == 0) res = compR(iterF->second, iterS->second);
if(res != 0) return res;
}
return 0;
diff --git a/alib2std/src/extensions/pair.hpp b/alib2std/src/extensions/pair.hpp
index dd820f5fef2ff16d946fa238a8fcdd54661ae27f..a635163296345cbde5a5636347293a189e63fee3 100644
--- a/alib2std/src/extensions/pair.hpp
+++ b/alib2std/src/extensions/pair.hpp
@@ -15,21 +15,54 @@
#include "utility.hpp"
#include "compare.hpp"
-namespace std {
+namespace ext {
+
+template < class T, class R >
+class pair : public std::pair < T, R > {
+public:
+#ifdef __clang__
+ using std::pair < T, R >::pair;
+ using std::pair < T, R >::operator =;
+#else
+ pair ( const pair & other ) noexcept : std::pair < T, R > ( other ) {
+ }
+
+ pair ( pair && other ) noexcept : std::pair < T, R > ( std::move ( other ) ) {
+ }
+
+ using std::pair < T, R >::pair;
+
+ pair & operator = ( pair && other ) noexcept {
+ static_cast < std::pair < T, R > & > ( * this ) = std::move ( other );
+ return * this;
+ }
+
+ pair & operator = ( const pair & other ) noexcept {
+ static_cast < std::pair < T, R > & > ( * this ) = other;
+ return * this;
+ }
+
+ using std::pair < T, R >::operator =;
+#endif
+};
+
+template<typename _T1, typename _T2>
+constexpr ext::pair < typename std::__decay_and_strip < _T1 >::__type, typename std::__decay_and_strip < _T2 >::__type > make_pair ( _T1 && __x, _T2 && __y ) {
+ typedef typename std::__decay_and_strip < _T1 >::__type __ds_type1;
+ typedef typename std::__decay_and_strip < _T2 >::__type __ds_type2;
+ typedef pair < __ds_type1, __ds_type2 > __pair_type;
+ return __pair_type ( std::forward < _T1 > ( __x ), std::forward < _T2 > ( __y ) );
+}
template< class T, class R >
-std::ostream& operator<<(std::ostream& out, const std::pair<T, R>& pair) {
+std::ostream& operator<<(std::ostream& out, const ext::pair<T, R>& pair) {
out << "(" << pair.first << ", " << pair.second << ")";
return out;
}
-} /* namespace std */
-
-namespace ext {
-
template < class T, class R >
-struct compare < std::pair < T, R > > {
- int operator ( ) ( const std::pair < T, R > & first, const std::pair < T, R > & second ) const {
+struct compare < ext::pair < T, R > > {
+ int operator ( ) ( const ext::pair < T, R > & first, const ext::pair < T, R > & second ) const {
static compare < typename std::decay < T >::type > compT;
static compare < typename std::decay < R >::type > compR;
@@ -40,7 +73,7 @@ struct compare < std::pair < T, R > > {
};
template < class T, class R >
-std::string to_string ( const std::pair < T, R > & value ) {
+std::string to_string ( const ext::pair < T, R > & value ) {
std::stringstream ss;
ss << value;
return ss.str();
diff --git a/alib2std/src/extensions/tuple.hpp b/alib2std/src/extensions/tuple.hpp
index ac17935927f163d3b788fef1d9aae93ff9167613..e5c875a96fa2b6cb5fbd6a7cfcbcb517ae247fd6 100644
--- a/alib2std/src/extensions/tuple.hpp
+++ b/alib2std/src/extensions/tuple.hpp
@@ -49,14 +49,15 @@ public:
#endif
};
-template < typename ... Ts >
-tuple < Ts ... > make_tuple( Ts && ... values ) {
- return tuple < Ts ... > (std::forward < Ts > ( values ) ... );
+template<typename... _Elements>
+constexpr tuple < typename std::__decay_and_strip < _Elements >::__type... > make_tuple ( _Elements && ... __args ) {
+ typedef tuple < typename std::__decay_and_strip < _Elements >::__type... > __result_type;
+ return __result_type ( std::forward < _Elements > ( __args ) ... );
}
-template < typename ... Ts >
-constexpr tuple < Ts & ... > tie ( Ts & ... values ) noexcept {
- return tuple < Ts & ... > ( values ... );
+template<typename ... _Elements >
+constexpr tuple < _Elements & ... > tie ( _Elements & ... __args ) noexcept {
+ return tuple < _Elements & ... > ( __args ... );
}
template < class ... Types >
diff --git a/alib2std/src/extensions/unordered_map.hpp b/alib2std/src/extensions/unordered_map.hpp
index d6ae42b28333a40670d6f4da968856a697a3c290..fa3eb659ef8be4b97d34c65b566d59bb50e18e72 100644
--- a/alib2std/src/extensions/unordered_map.hpp
+++ b/alib2std/src/extensions/unordered_map.hpp
@@ -57,7 +57,7 @@ std::ostream& operator<<(std::ostream& out, const ext::unordered_map<T, R, Ts ..
for(const std::pair<const T, R>& item : map) {
if(!first) out << ", ";
first = false;
- out << item;
+ out << "(" << item.first << ", " << item.second << ")";
}
out << "}";
diff --git a/alib2std/test-src/extensions/CompareTest.cpp b/alib2std/test-src/extensions/CompareTest.cpp
index f01d68901274ee414d7c449bd58610e269ef5e3f..fe351d2b6c36a17a78e8d073f5543a891ecc76c7 100644
--- a/alib2std/test-src/extensions/CompareTest.cpp
+++ b/alib2std/test-src/extensions/CompareTest.cpp
@@ -28,10 +28,10 @@ void CompareTest::testCompare() {
ext::compare<ext::set<ext::vector<int>>> comp2;
CPPUNIT_ASSERT(comp2(set1, set2) < 0);
- std::pair<ext::set<ext::vector<int>>, ext::set<ext::vector<int>>> pair1 {set1, set2};
- std::pair<ext::set<ext::vector<int>>, ext::set<ext::vector<int>>> pair2 {set2, set1};
+ ext::pair<ext::set<ext::vector<int>>, ext::set<ext::vector<int>>> pair1 {set1, set2};
+ ext::pair<ext::set<ext::vector<int>>, ext::set<ext::vector<int>>> pair2 {set2, set1};
- ext::compare<std::pair<ext::set<ext::vector<int>>, ext::set<ext::vector<int>>>> comp3;
+ ext::compare<ext::pair<ext::set<ext::vector<int>>, ext::set<ext::vector<int>>>> comp3;
CPPUNIT_ASSERT(comp3(pair1, pair2) < 0);
int two = 2;
diff --git a/alib2std/test-src/extensions/OstreamTest.cpp b/alib2std/test-src/extensions/OstreamTest.cpp
index 97c777dbc342ae0d0d901b881f3c00527535800e..c68d893f55e80c73e46ed2605adc16504d5f60b9 100644
--- a/alib2std/test-src/extensions/OstreamTest.cpp
+++ b/alib2std/test-src/extensions/OstreamTest.cpp
@@ -30,8 +30,8 @@ void OstreamTest::testOstream() {
std::cout << ss2.str() << std::endl;
CPPUNIT_ASSERT("{[1, 2, 3]}" == ss2.str());
- std::pair<ext::set<ext::vector<int>>, ext::set<ext::vector<int>>> pair1 {set1, set2};
- std::pair<ext::set<ext::vector<int>>, ext::set<ext::vector<int>>> pair2 {set2, set1};
+ ext::pair<ext::set<ext::vector<int>>, ext::set<ext::vector<int>>> pair1 {set1, set2};
+ ext::pair<ext::set<ext::vector<int>>, ext::set<ext::vector<int>>> pair2 {set2, set1};
std::stringstream ss3;
ss3 << pair1;
diff --git a/alib2str/src/automaton/AutomatonToStringComposer.h b/alib2str/src/automaton/AutomatonToStringComposer.h
index f59c10f106ccc26a0ad533ad2111884887950c43..b2d868355d007e863e1036ea1afea31c66e3c864 100644
--- a/alib2str/src/automaton/AutomatonToStringComposer.h
+++ b/alib2str/src/automaton/AutomatonToStringComposer.h
@@ -51,7 +51,7 @@ public:
template < class SymbolType, class StateType >
void AutomatonToStringComposer::composeTransitionsFromState(std::ostream& out, const DFA < SymbolType, StateType > & automaton, const StateType & from) {
- ext::range < typename ext::map < std::pair < StateType, SymbolType >, StateType >::const_iterator > symbolTransitionsFromState = automaton.getTransitionsFromState(from);
+ ext::range < typename ext::map < ext::pair < StateType, SymbolType >, StateType >::const_iterator > symbolTransitionsFromState = automaton.getTransitionsFromState(from);
for(const SymbolType& inputSymbol : automaton.getInputAlphabet()) {
if ( ! symbolTransitionsFromState.empty ( ) && symbolTransitionsFromState.front ( ).first.second == inputSymbol ) {
@@ -66,10 +66,10 @@ void AutomatonToStringComposer::composeTransitionsFromState(std::ostream& out, c
template < class SymbolType, class StateType >
void AutomatonToStringComposer::composeTransitionsFromState(std::ostream& out, const NFA < SymbolType, StateType > & automaton, const StateType & from) {
- ext::map<std::pair<StateType, SymbolType>, ext::set<StateType> > symbolTransitionsFromState = automaton.getTransitionsFromState(from);
+ ext::map<ext::pair<StateType, SymbolType>, ext::set<StateType> > symbolTransitionsFromState = automaton.getTransitionsFromState(from);
for(const SymbolType& inputSymbol : automaton.getInputAlphabet()) {
- const typename ext::map<std::pair<StateType, SymbolType>, ext::set<StateType> >::iterator toStates = symbolTransitionsFromState.find(std::make_pair(from, inputSymbol));
+ const typename ext::map<ext::pair<StateType, SymbolType>, ext::set<StateType> >::iterator toStates = symbolTransitionsFromState.find(ext::make_pair(from, inputSymbol));
if(toStates == symbolTransitionsFromState.end() || toStates->second.size() == 0) {
out << " -";
} else {
@@ -85,10 +85,10 @@ void AutomatonToStringComposer::composeTransitionsFromState(std::ostream& out, c
template < class SymbolType, class StateType >
void AutomatonToStringComposer::composeTransitionsFromState(std::ostream& out, const MultiInitialStateNFA < SymbolType, StateType > & automaton, const StateType & from) {
- ext::map<std::pair<StateType, SymbolType>, ext::set<StateType> > symbolTransitionsFromState = automaton.getTransitionsFromState(from);
+ ext::map<ext::pair<StateType, SymbolType>, ext::set<StateType> > symbolTransitionsFromState = automaton.getTransitionsFromState(from);
for(const SymbolType& inputSymbol : automaton.getInputAlphabet()) {
- const typename ext::map<std::pair<StateType, SymbolType>, ext::set<StateType> >::iterator toStates = symbolTransitionsFromState.find(std::make_pair(from, inputSymbol));
+ const typename ext::map<ext::pair<StateType, SymbolType>, ext::set<StateType> >::iterator toStates = symbolTransitionsFromState.find(ext::make_pair(from, inputSymbol));
if(toStates == symbolTransitionsFromState.end() || toStates->second.size() == 0) {
out << " -";
} else {
@@ -104,10 +104,10 @@ void AutomatonToStringComposer::composeTransitionsFromState(std::ostream& out, c
template < class SymbolType, class EpsilonType, class StateType >
void AutomatonToStringComposer::composeTransitionsFromState(std::ostream& out, const EpsilonNFA < SymbolType, EpsilonType, StateType > & automaton, const StateType & from) {
- ext::map<std::pair<StateType, SymbolType>, ext::set<StateType> > symbolTransitionsFromState = automaton.getSymbolTransitionsFromState(from);
+ ext::map<ext::pair<StateType, SymbolType>, ext::set<StateType> > symbolTransitionsFromState = automaton.getSymbolTransitionsFromState(from);
for(const SymbolType& inputSymbol : automaton.getInputAlphabet()) {
- const typename ext::map<std::pair<StateType, SymbolType>, ext::set<StateType> >::iterator toStates = symbolTransitionsFromState.find(std::make_pair(from, inputSymbol));
+ const typename ext::map<ext::pair<StateType, SymbolType>, ext::set<StateType> >::iterator toStates = symbolTransitionsFromState.find(ext::make_pair(from, inputSymbol));
if(toStates == symbolTransitionsFromState.end() || toStates->second.size() == 0) {
out << " -";
} else {
diff --git a/alib2str/src/object/ObjectFromStringParser.cpp b/alib2str/src/object/ObjectFromStringParser.cpp
index 0b56d0875a0635d11f2ac5e69e764056a91d656e..eb1a92846d2ab55c02ecb07a55ece78431a4c93e 100644
--- a/alib2str/src/object/ObjectFromStringParser.cpp
+++ b/alib2str/src/object/ObjectFromStringParser.cpp
@@ -55,7 +55,7 @@ Object ObjectFromStringParser::parseObject(std::istream& input) {
if(token.type != ObjectFromStringLexer::TokenType::PAIR_END)
throw exception::CommonException("Expected PAIR_END token.");
- return Object(container::ObjectsPair < > (std::make_pair(firstObject, secondObject)));
+ return Object(container::ObjectsPair < > (ext::make_pair(firstObject, secondObject)));
}
case ObjectFromStringLexer::TokenType::SET_END:
throw exception::CommonException("Unexpected start of Object SET_END.");