Skip to content
Snippets Groups Projects
Commit d6da4a44 authored by Jan Trávníček's avatar Jan Trávníček
Browse files

add std::move to all parsers

parent b08f8211
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
Showing
with 203 additions and 205 deletions
alib2data/src/alphabet/SymbolFromXMLParser.cpp
+ 7
− 10
View file @ d6da4a44
...@@ -72,7 +72,7 @@ LabeledSymbol SymbolFromXMLParser::parseLabeledSymbol(std::list<sax::Token>& inp ...@@ -72,7 +72,7 @@ LabeledSymbol SymbolFromXMLParser::parseLabeledSymbol(std::list<sax::Token>& inp
popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALPHABET_LABELED_SYMBOL); popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALPHABET_LABELED_SYMBOL);
label::Label data = alib::xmlApi<label::Label>::parse(input); label::Label data = alib::xmlApi<label::Label>::parse(input);
popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_LABELED_SYMBOL); popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_LABELED_SYMBOL);
return LabeledSymbol(data); return LabeledSymbol(std::move(data));
} }
   
BlankSymbol SymbolFromXMLParser::parseBlankSymbol(std::list<sax::Token>& input) const { BlankSymbol SymbolFromXMLParser::parseBlankSymbol(std::list<sax::Token>& input) const {
...@@ -104,7 +104,7 @@ RankedSymbol SymbolFromXMLParser::parseRankedSymbol(std::list<sax::Token>& input ...@@ -104,7 +104,7 @@ RankedSymbol SymbolFromXMLParser::parseRankedSymbol(std::list<sax::Token>& input
label::Label data = alib::xmlApi<label::Label>::parse(input); label::Label data = alib::xmlApi<label::Label>::parse(input);
primitive::Integer rank = alib::xmlApi<primitive::Integer>::parse(input); primitive::Integer rank = alib::xmlApi<primitive::Integer>::parse(input);
popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_RANKED_SYMBOL); popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_RANKED_SYMBOL);
return RankedSymbol(data, rank); return RankedSymbol(std::move(data), std::move(rank));
} }
   
BarSymbol SymbolFromXMLParser::parseBarSymbol(std::list<sax::Token>& input) const { BarSymbol SymbolFromXMLParser::parseBarSymbol(std::list<sax::Token>& input) const {
...@@ -117,7 +117,7 @@ RankedBarSymbol SymbolFromXMLParser::parseRankedBarSymbol(std::list<sax::Token>& ...@@ -117,7 +117,7 @@ RankedBarSymbol SymbolFromXMLParser::parseRankedBarSymbol(std::list<sax::Token>&
popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALPHABET_RANKED_BAR_SYMBOL); popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALPHABET_RANKED_BAR_SYMBOL);
primitive::Integer rank = alib::xmlApi<primitive::Integer>::parse(input); primitive::Integer rank = alib::xmlApi<primitive::Integer>::parse(input);
popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_RANKED_BAR_SYMBOL); popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_RANKED_BAR_SYMBOL);
return RankedBarSymbol(rank); return RankedBarSymbol(std::move(rank));
} }
   
SubtreeWildcardSymbol SymbolFromXMLParser::parseSubtreeWildcardSymbol(std::list<sax::Token>& input) const { SubtreeWildcardSymbol SymbolFromXMLParser::parseSubtreeWildcardSymbol(std::list<sax::Token>& input) const {
...@@ -132,9 +132,8 @@ SymbolSetSymbol SymbolFromXMLParser::parseSymbolSetSymbol(std::list<sax::Token>& ...@@ -132,9 +132,8 @@ SymbolSetSymbol SymbolFromXMLParser::parseSymbolSetSymbol(std::list<sax::Token>&
while(isTokenType(input, sax::Token::TokenType::START_ELEMENT)) { while(isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
labels.insert(parseSymbol(input)); labels.insert(parseSymbol(input));
} }
SymbolSetSymbol data(labels);
popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_SYMBOL_SET_SYMBOL); popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_SYMBOL_SET_SYMBOL);
return data; return SymbolSetSymbol(std::move(labels));
} }
   
SymbolPairSymbol SymbolFromXMLParser::parseSymbolPairSymbol(std::list<sax::Token>& input) const { SymbolPairSymbol SymbolFromXMLParser::parseSymbolPairSymbol(std::list<sax::Token>& input) const {
...@@ -143,20 +142,18 @@ SymbolPairSymbol SymbolFromXMLParser::parseSymbolPairSymbol(std::list<sax::Token ...@@ -143,20 +142,18 @@ SymbolPairSymbol SymbolFromXMLParser::parseSymbolPairSymbol(std::list<sax::Token
Symbol firstSymbol = parseSymbol(input); Symbol firstSymbol = parseSymbol(input);
Symbol secondSymbol = parseSymbol(input); Symbol secondSymbol = parseSymbol(input);
   
SymbolPairSymbol data(std::make_pair(firstSymbol, secondSymbol));
popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_SYMBOL_PAIR_SYMBOL); popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_SYMBOL_PAIR_SYMBOL);
return data; return SymbolPairSymbol(std::make_pair(std::move(firstSymbol), std::move(secondSymbol)));
} }
   
UniqueSymbol SymbolFromXMLParser::parseUniqueSymbol(std::list<sax::Token>& input) const { UniqueSymbol SymbolFromXMLParser::parseUniqueSymbol(std::list<sax::Token>& input) const {
popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALPHABET_UNIQUE_SYMBOL); popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALPHABET_UNIQUE_SYMBOL);
Symbol firstSymbol = parseSymbol(input); Symbol firstSymbol = parseSymbol(input);
primitive::Integer secondSymbol = alib::xmlApi<primitive::Integer>::parse(input); primitive::Integer secondSymbol = alib::xmlApi<primitive::Integer>::parse(input);
   
UniqueSymbol data(firstSymbol, secondSymbol);
popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_UNIQUE_SYMBOL); popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_UNIQUE_SYMBOL);
return data; return UniqueSymbol(std::move(firstSymbol), std::move(secondSymbol));
} }
   
} /* namespace alphabet */ } /* namespace alphabet */
alib2data/src/automaton/AutomatonFromXMLParser.cpp
+ 113
− 113
View file @ d6da4a44
...@@ -100,10 +100,10 @@ DFA AutomatonFromXMLParser::parseDFA(std::list<sax::Token>& input) const { ...@@ -100,10 +100,10 @@ DFA AutomatonFromXMLParser::parseDFA(std::list<sax::Token>& input) const {
State initialState = parseInitialState(input); State initialState = parseInitialState(input);
std::set<State> finalStates = parseFinalStates(input); std::set<State> finalStates = parseFinalStates(input);
   
DFA automaton(initialState); DFA automaton(std::move(initialState));
automaton.setStates(states); automaton.setStates(std::move(states));
automaton.setInputAlphabet(inputSymbols); automaton.setInputAlphabet(std::move(inputSymbols));
automaton.setFinalStates(finalStates); automaton.setFinalStates(std::move(finalStates));
   
parseTransitions<DFA>(input, automaton); parseTransitions<DFA>(input, automaton);
   
...@@ -119,10 +119,10 @@ NFA AutomatonFromXMLParser::parseNFA(std::list<sax::Token>& input) const { ...@@ -119,10 +119,10 @@ NFA AutomatonFromXMLParser::parseNFA(std::list<sax::Token>& input) const {
State initialState = parseInitialState(input); State initialState = parseInitialState(input);
std::set<State> finalStates = parseFinalStates(input); std::set<State> finalStates = parseFinalStates(input);
   
NFA automaton(initialState); NFA automaton(std::move(initialState));
automaton.setStates(states); automaton.setStates(std::move(states));
automaton.setInputAlphabet(inputSymbols); automaton.setInputAlphabet(std::move(inputSymbols));
automaton.setFinalStates(finalStates); automaton.setFinalStates(std::move(finalStates));
   
parseTransitions<NFA>(input, automaton); parseTransitions<NFA>(input, automaton);
   
...@@ -139,10 +139,10 @@ MultiInitialStateNFA AutomatonFromXMLParser::parseMultiInitialStateNFA(std::list ...@@ -139,10 +139,10 @@ MultiInitialStateNFA AutomatonFromXMLParser::parseMultiInitialStateNFA(std::list
std::set<State> finalStates = parseFinalStates(input); std::set<State> finalStates = parseFinalStates(input);
   
MultiInitialStateNFA automaton; MultiInitialStateNFA automaton;
automaton.setStates(states); automaton.setStates(std::move(states));
automaton.setInputAlphabet(inputSymbols); automaton.setInputAlphabet(std::move(inputSymbols));
automaton.setInitialStates(initialStates); automaton.setInitialStates(std::move(initialStates));
automaton.setFinalStates(finalStates); automaton.setFinalStates(std::move(finalStates));
   
parseTransitions<MultiInitialStateNFA>(input, automaton); parseTransitions<MultiInitialStateNFA>(input, automaton);
   
...@@ -158,10 +158,10 @@ EpsilonNFA AutomatonFromXMLParser::parseEpsilonNFA(std::list<sax::Token>& input) ...@@ -158,10 +158,10 @@ EpsilonNFA AutomatonFromXMLParser::parseEpsilonNFA(std::list<sax::Token>& input)
State initialState = parseInitialState(input); State initialState = parseInitialState(input);
std::set<State> finalStates = parseFinalStates(input); std::set<State> finalStates = parseFinalStates(input);
   
EpsilonNFA automaton(initialState); EpsilonNFA automaton(std::move(initialState));
automaton.setStates(states); automaton.setStates(std::move(states));
automaton.setInputAlphabet(inputSymbols); automaton.setInputAlphabet(std::move(inputSymbols));
automaton.setFinalStates(finalStates); automaton.setFinalStates(std::move(finalStates));
   
parseTransitions<EpsilonNFA>(input, automaton); parseTransitions<EpsilonNFA>(input, automaton);
   
...@@ -177,10 +177,10 @@ CompactNFA AutomatonFromXMLParser::parseCompactNFA(std::list<sax::Token>& input) ...@@ -177,10 +177,10 @@ CompactNFA AutomatonFromXMLParser::parseCompactNFA(std::list<sax::Token>& input)
State initialState = parseInitialState(input); State initialState = parseInitialState(input);
std::set<State> finalStates = parseFinalStates(input); std::set<State> finalStates = parseFinalStates(input);
   
CompactNFA automaton(initialState); CompactNFA automaton(std::move(initialState));
automaton.setStates(states); automaton.setStates(std::move(states));
automaton.setInputAlphabet(inputSymbols); automaton.setInputAlphabet(std::move(inputSymbols));
automaton.setFinalStates(finalStates); automaton.setFinalStates(std::move(finalStates));
   
parseTransitions<CompactNFA>(input, automaton); parseTransitions<CompactNFA>(input, automaton);
   
...@@ -196,10 +196,10 @@ ExtendedNFA AutomatonFromXMLParser::parseExtendedNFA(std::list<sax::Token>& inpu ...@@ -196,10 +196,10 @@ ExtendedNFA AutomatonFromXMLParser::parseExtendedNFA(std::list<sax::Token>& inpu
State initialState = parseInitialState(input); State initialState = parseInitialState(input);
std::set<State> finalStates = parseFinalStates(input); std::set<State> finalStates = parseFinalStates(input);
   
ExtendedNFA automaton(initialState); ExtendedNFA automaton(std::move(initialState));
automaton.setStates(states); automaton.setStates(std::move(states));
automaton.setInputAlphabet(inputSymbols); automaton.setInputAlphabet(std::move(inputSymbols));
automaton.setFinalStates(finalStates); automaton.setFinalStates(std::move(finalStates));
   
parseTransitions<ExtendedNFA>(input, automaton); parseTransitions<ExtendedNFA>(input, automaton);
   
...@@ -217,11 +217,11 @@ DPDA AutomatonFromXMLParser::parseDPDA(std::list<sax::Token>& input) const { ...@@ -217,11 +217,11 @@ DPDA AutomatonFromXMLParser::parseDPDA(std::list<sax::Token>& input) const {
alphabet::Symbol initialStackSymbol = parseInitialStackSymbol(input); alphabet::Symbol initialStackSymbol = parseInitialStackSymbol(input);
std::set<State> finalStates = parseFinalStates(input); std::set<State> finalStates = parseFinalStates(input);
   
DPDA automaton(initialState, initialStackSymbol); DPDA automaton(std::move(initialState), std::move(initialStackSymbol));
automaton.setStates(states); automaton.setStates(std::move(states));
automaton.setInputAlphabet(inputSymbols); automaton.setInputAlphabet(std::move(inputSymbols));
automaton.setStackAlphabet(stackSymbols); automaton.setStackAlphabet(std::move(stackSymbols));
automaton.setFinalStates(finalStates); automaton.setFinalStates(std::move(finalStates));
   
parseTransitions<DPDA>(input, automaton); parseTransitions<DPDA>(input, automaton);
   
...@@ -240,11 +240,11 @@ SinglePopDPDA AutomatonFromXMLParser::parseSinglePopDPDA(std::list<sax::Token>& ...@@ -240,11 +240,11 @@ SinglePopDPDA AutomatonFromXMLParser::parseSinglePopDPDA(std::list<sax::Token>&
alphabet::Symbol initialStackSymbol = parseInitialStackSymbol(input); alphabet::Symbol initialStackSymbol = parseInitialStackSymbol(input);
std::set<State> finalStates = parseFinalStates(input); std::set<State> finalStates = parseFinalStates(input);
   
SinglePopDPDA automaton(initialState, initialStackSymbol); SinglePopDPDA automaton(std::move(initialState), std::move(initialStackSymbol));
automaton.setStates(states); automaton.setStates(std::move(states));
automaton.setInputAlphabet(inputSymbols); automaton.setInputAlphabet(std::move(inputSymbols));
automaton.setStackAlphabet(stackSymbols); automaton.setStackAlphabet(std::move(stackSymbols));
automaton.setFinalStates(finalStates); automaton.setFinalStates(std::move(finalStates));
   
parseTransitions<SinglePopDPDA>(input, automaton); parseTransitions<SinglePopDPDA>(input, automaton);
   
...@@ -263,11 +263,11 @@ InputDrivenDPDA AutomatonFromXMLParser::parseInputDrivenDPDA(std::list<sax::Toke ...@@ -263,11 +263,11 @@ InputDrivenDPDA AutomatonFromXMLParser::parseInputDrivenDPDA(std::list<sax::Toke
alphabet::Symbol initialStackSymbol = parseInitialStackSymbol(input); alphabet::Symbol initialStackSymbol = parseInitialStackSymbol(input);
std::set<State> finalStates = parseFinalStates(input); std::set<State> finalStates = parseFinalStates(input);
   
InputDrivenDPDA automaton(initialState, initialStackSymbol); InputDrivenDPDA automaton(std::move(initialState), std::move(initialStackSymbol));
automaton.setStates(states); automaton.setStates(std::move(states));
automaton.setInputAlphabet(inputSymbols); automaton.setInputAlphabet(std::move(inputSymbols));
automaton.setStackAlphabet(stackSymbols); automaton.setStackAlphabet(std::move(stackSymbols));
automaton.setFinalStates(finalStates); automaton.setFinalStates(std::move(finalStates));
   
parseInputToPushdownStoreOperation(input, automaton); parseInputToPushdownStoreOperation(input, automaton);
parseTransitions<InputDrivenDPDA>(input, automaton); parseTransitions<InputDrivenDPDA>(input, automaton);
...@@ -287,11 +287,11 @@ InputDrivenNPDA AutomatonFromXMLParser::parseInputDrivenNPDA(std::list<sax::Toke ...@@ -287,11 +287,11 @@ InputDrivenNPDA AutomatonFromXMLParser::parseInputDrivenNPDA(std::list<sax::Toke
alphabet::Symbol initialStackSymbol = parseInitialStackSymbol(input); alphabet::Symbol initialStackSymbol = parseInitialStackSymbol(input);
std::set<State> finalStates = parseFinalStates(input); std::set<State> finalStates = parseFinalStates(input);
   
InputDrivenNPDA automaton(initialState, initialStackSymbol); InputDrivenNPDA automaton(std::move(initialState), std::move(initialStackSymbol));
automaton.setStates(states); automaton.setStates(std::move(states));
automaton.setInputAlphabet(inputSymbols); automaton.setInputAlphabet(std::move(inputSymbols));
automaton.setStackAlphabet(stackSymbols); automaton.setStackAlphabet(std::move(stackSymbols));
automaton.setFinalStates(finalStates); automaton.setFinalStates(std::move(finalStates));
   
parseInputToPushdownStoreOperation(input, automaton); parseInputToPushdownStoreOperation(input, automaton);
parseTransitions<InputDrivenNPDA>(input, automaton); parseTransitions<InputDrivenNPDA>(input, automaton);
...@@ -313,13 +313,13 @@ VisiblyPushdownDPDA AutomatonFromXMLParser::parseVisiblyPushdownDPDA(std::list<s ...@@ -313,13 +313,13 @@ VisiblyPushdownDPDA AutomatonFromXMLParser::parseVisiblyPushdownDPDA(std::list<s
alphabet::Symbol bottomOfTheStackSymbol = parseBottomOfTheStackSymbol(input); alphabet::Symbol bottomOfTheStackSymbol = parseBottomOfTheStackSymbol(input);
std::set<State> finalStates = parseFinalStates(input); std::set<State> finalStates = parseFinalStates(input);
   
VisiblyPushdownDPDA automaton(initialState, bottomOfTheStackSymbol); VisiblyPushdownDPDA automaton(std::move(initialState), std::move(bottomOfTheStackSymbol));
automaton.setStates(states); automaton.setStates(std::move(states));
automaton.setCallInputAlphabet(callInputAlphabet); automaton.setCallInputAlphabet(std::move(callInputAlphabet));
automaton.setReturnInputAlphabet(returnInputAlphabet); automaton.setReturnInputAlphabet(std::move(returnInputAlphabet));
automaton.setLocalInputAlphabet(localInputAlphabet); automaton.setLocalInputAlphabet(std::move(localInputAlphabet));
automaton.setStackAlphabet(stackSymbols); automaton.setStackAlphabet(std::move(stackSymbols));
automaton.setFinalStates(finalStates); automaton.setFinalStates(std::move(finalStates));
   
parseTransitions<VisiblyPushdownDPDA>(input, automaton); parseTransitions<VisiblyPushdownDPDA>(input, automaton);
   
...@@ -340,14 +340,14 @@ VisiblyPushdownNPDA AutomatonFromXMLParser::parseVisiblyPushdownNPDA(std::list<s ...@@ -340,14 +340,14 @@ VisiblyPushdownNPDA AutomatonFromXMLParser::parseVisiblyPushdownNPDA(std::list<s
alphabet::Symbol bottomOfTheStackSymbol = parseBottomOfTheStackSymbol(input); alphabet::Symbol bottomOfTheStackSymbol = parseBottomOfTheStackSymbol(input);
std::set<State> finalStates = parseFinalStates(input); std::set<State> finalStates = parseFinalStates(input);
   
VisiblyPushdownNPDA automaton(bottomOfTheStackSymbol); VisiblyPushdownNPDA automaton(std::move(bottomOfTheStackSymbol));
automaton.setStates(states); automaton.setStates(std::move(states));
automaton.setCallInputAlphabet(callInputAlphabet); automaton.setCallInputAlphabet(std::move(callInputAlphabet));
automaton.setReturnInputAlphabet(returnInputAlphabet); automaton.setReturnInputAlphabet(std::move(returnInputAlphabet));
automaton.setLocalInputAlphabet(localInputAlphabet); automaton.setLocalInputAlphabet(std::move(localInputAlphabet));
automaton.setStackAlphabet(stackSymbols); automaton.setStackAlphabet(std::move(stackSymbols));
automaton.setInitialStates(initialStates); automaton.setInitialStates(std::move(initialStates));
automaton.setFinalStates(finalStates); automaton.setFinalStates(std::move(finalStates));
   
parseTransitions<VisiblyPushdownNPDA>(input, automaton); parseTransitions<VisiblyPushdownNPDA>(input, automaton);
   
...@@ -366,11 +366,11 @@ RealTimeHeightDeterministicDPDA AutomatonFromXMLParser::parseRealTimeHeightDeter ...@@ -366,11 +366,11 @@ RealTimeHeightDeterministicDPDA AutomatonFromXMLParser::parseRealTimeHeightDeter
alphabet::Symbol bottomOfTheStackSymbol = parseBottomOfTheStackSymbol(input); alphabet::Symbol bottomOfTheStackSymbol = parseBottomOfTheStackSymbol(input);
std::set<State> finalStates = parseFinalStates(input); std::set<State> finalStates = parseFinalStates(input);
   
RealTimeHeightDeterministicDPDA automaton(initialState, bottomOfTheStackSymbol); RealTimeHeightDeterministicDPDA automaton(std::move(initialState), std::move(bottomOfTheStackSymbol));
automaton.setStates(states); automaton.setStates(std::move(states));
automaton.setInputAlphabet(inputSymbols); automaton.setInputAlphabet(std::move(inputSymbols));
automaton.setStackAlphabet(stackSymbols); automaton.setStackAlphabet(std::move(stackSymbols));
automaton.setFinalStates(finalStates); automaton.setFinalStates(std::move(finalStates));
   
parseTransitions<RealTimeHeightDeterministicDPDA>(input, automaton); parseTransitions<RealTimeHeightDeterministicDPDA>(input, automaton);
   
...@@ -389,12 +389,12 @@ RealTimeHeightDeterministicNPDA AutomatonFromXMLParser::parseRealTimeHeightDeter ...@@ -389,12 +389,12 @@ RealTimeHeightDeterministicNPDA AutomatonFromXMLParser::parseRealTimeHeightDeter
alphabet::Symbol bottomOfTheStackSymbol = parseBottomOfTheStackSymbol(input); alphabet::Symbol bottomOfTheStackSymbol = parseBottomOfTheStackSymbol(input);
std::set<State> finalStates = parseFinalStates(input); std::set<State> finalStates = parseFinalStates(input);
   
RealTimeHeightDeterministicNPDA automaton(bottomOfTheStackSymbol); RealTimeHeightDeterministicNPDA automaton(std::move(bottomOfTheStackSymbol));
automaton.setStates(states); automaton.setStates(std::move(states));
automaton.setInputAlphabet(inputSymbols); automaton.setInputAlphabet(std::move(inputSymbols));
automaton.setStackAlphabet(stackSymbols); automaton.setStackAlphabet(std::move(stackSymbols));
automaton.setInitialStates(initialStates); automaton.setInitialStates(std::move(initialStates));
automaton.setFinalStates(finalStates); automaton.setFinalStates(std::move(finalStates));
   
parseTransitions<RealTimeHeightDeterministicNPDA>(input, automaton); parseTransitions<RealTimeHeightDeterministicNPDA>(input, automaton);
   
...@@ -413,11 +413,11 @@ NPDA AutomatonFromXMLParser::parseNPDA(std::list<sax::Token>& input) const { ...@@ -413,11 +413,11 @@ NPDA AutomatonFromXMLParser::parseNPDA(std::list<sax::Token>& input) const {
alphabet::Symbol initialStackSymbol = parseInitialStackSymbol(input); alphabet::Symbol initialStackSymbol = parseInitialStackSymbol(input);
std::set<State> finalStates = parseFinalStates(input); std::set<State> finalStates = parseFinalStates(input);
   
NPDA automaton(initialState, initialStackSymbol); NPDA automaton(std::move(initialState), std::move(initialStackSymbol));
automaton.setStates(states); automaton.setStates(std::move(states));
automaton.setInputAlphabet(inputSymbols); automaton.setInputAlphabet(std::move(inputSymbols));
automaton.setStackAlphabet(stackSymbols); automaton.setStackAlphabet(std::move(stackSymbols));
automaton.setFinalStates(finalStates); automaton.setFinalStates(std::move(finalStates));
   
parseTransitions<NPDA>(input, automaton); parseTransitions<NPDA>(input, automaton);
   
...@@ -436,11 +436,11 @@ SinglePopNPDA AutomatonFromXMLParser::parseSinglePopNPDA(std::list<sax::Token>& ...@@ -436,11 +436,11 @@ SinglePopNPDA AutomatonFromXMLParser::parseSinglePopNPDA(std::list<sax::Token>&
alphabet::Symbol initialStackSymbol = parseInitialStackSymbol(input); alphabet::Symbol initialStackSymbol = parseInitialStackSymbol(input);
std::set<State> finalStates = parseFinalStates(input); std::set<State> finalStates = parseFinalStates(input);
   
SinglePopNPDA automaton(initialState, initialStackSymbol); SinglePopNPDA automaton(std::move(initialState), std::move(initialStackSymbol));
automaton.setStates(states); automaton.setStates(std::move(states));
automaton.setInputAlphabet(inputSymbols); automaton.setInputAlphabet(std::move(inputSymbols));
automaton.setStackAlphabet(stackSymbols); automaton.setStackAlphabet(std::move(stackSymbols));
automaton.setFinalStates(finalStates); automaton.setFinalStates(std::move(finalStates));
   
parseTransitions<SinglePopNPDA>(input, automaton); parseTransitions<SinglePopNPDA>(input, automaton);
   
...@@ -459,12 +459,12 @@ OneTapeDTM AutomatonFromXMLParser::parseOneTapeDTM(std::list<sax::Token>& input) ...@@ -459,12 +459,12 @@ OneTapeDTM AutomatonFromXMLParser::parseOneTapeDTM(std::list<sax::Token>& input)
State initialState = parseInitialState(input); State initialState = parseInitialState(input);
std::set<State> finalStates = parseFinalStates(input); std::set<State> finalStates = parseFinalStates(input);
   
OneTapeDTM automaton(initialState, blank); OneTapeDTM automaton(std::move(initialState), std::move(blank));
automaton.setStates(states); automaton.setStates(std::move(states));
automaton.setTapeAlphabet(tapeSymbols); automaton.setTapeAlphabet(std::move(tapeSymbols));
automaton.setInputAlphabet(inputSymbols); automaton.setInputAlphabet(std::move(inputSymbols));
automaton.setInitialState(initialState); automaton.setInitialState(std::move(initialState));
automaton.setFinalStates(finalStates); automaton.setFinalStates(std::move(finalStates));
   
parseTransitions<OneTapeDTM>(input, automaton); parseTransitions<OneTapeDTM>(input, automaton);
   
...@@ -614,7 +614,7 @@ void AutomatonFromXMLParser::parseInputToPushdownStoreOperation(std::list<sax::T ...@@ -614,7 +614,7 @@ void AutomatonFromXMLParser::parseInputToPushdownStoreOperation(std::list<sax::T
std::vector<alphabet::Symbol> pop = parseTransitionPop(input); std::vector<alphabet::Symbol> pop = parseTransitionPop(input);
std::vector<alphabet::Symbol> push = parseTransitionPush(input); std::vector<alphabet::Symbol> push = parseTransitionPush(input);
   
automaton.setPushdownStoreOperation(inputSymbol, pop, push); automaton.setPushdownStoreOperation(std::move(inputSymbol), std::move(pop), std::move(push));
   
popToken(input, sax::Token::TokenType::END_ELEMENT, "operation"); popToken(input, sax::Token::TokenType::END_ELEMENT, "operation");
} }
...@@ -631,7 +631,7 @@ void AutomatonFromXMLParser::parseInputToPushdownStoreOperation(std::list<sax::T ...@@ -631,7 +631,7 @@ void AutomatonFromXMLParser::parseInputToPushdownStoreOperation(std::list<sax::T
std::vector<alphabet::Symbol> pop = parseTransitionPop(input); std::vector<alphabet::Symbol> pop = parseTransitionPop(input);
std::vector<alphabet::Symbol> push = parseTransitionPush(input); std::vector<alphabet::Symbol> push = parseTransitionPush(input);
   
automaton.setPushdownStoreOperation(inputSymbol, pop, push); automaton.setPushdownStoreOperation(std::move(inputSymbol), std::move(pop), std::move(push));
   
popToken(input, sax::Token::TokenType::END_ELEMENT, "operation"); popToken(input, sax::Token::TokenType::END_ELEMENT, "operation");
} }
...@@ -645,7 +645,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, DFA& ...@@ -645,7 +645,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, DFA&
State to = parseTransitionTo(input); State to = parseTransitionTo(input);
popToken(input, sax::Token::TokenType::END_ELEMENT, "transition"); popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
   
automaton.addTransition(from, inputSymbol, to); automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(to));
} }
   
void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, MultiInitialStateNFA& automaton) const { void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, MultiInitialStateNFA& automaton) const {
...@@ -655,7 +655,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Multi ...@@ -655,7 +655,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Multi
State to = parseTransitionTo(input); State to = parseTransitionTo(input);
popToken(input, sax::Token::TokenType::END_ELEMENT, "transition"); popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
   
automaton.addTransition(from, inputSymbol, to); automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(to));
} }
   
void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, NFA& automaton) const { void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, NFA& automaton) const {
...@@ -665,7 +665,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, NFA& ...@@ -665,7 +665,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, NFA&
State to = parseTransitionTo(input); State to = parseTransitionTo(input);
popToken(input, sax::Token::TokenType::END_ELEMENT, "transition"); popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
   
automaton.addTransition(from, inputSymbol, to); automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(to));
} }
   
void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, EpsilonNFA& automaton) const { void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, EpsilonNFA& automaton) const {
...@@ -675,7 +675,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Epsil ...@@ -675,7 +675,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Epsil
State to = parseTransitionTo(input); State to = parseTransitionTo(input);
popToken(input, sax::Token::TokenType::END_ELEMENT, "transition"); popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
   
automaton.addTransition(from, inputVariant, to); automaton.addTransition(std::move(from), std::move(inputVariant), std::move(to));
} }
   
void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, CompactNFA& automaton) const { void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, CompactNFA& automaton) const {
...@@ -685,7 +685,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Compa ...@@ -685,7 +685,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Compa
State to = parseTransitionTo(input); State to = parseTransitionTo(input);
popToken(input, sax::Token::TokenType::END_ELEMENT, "transition"); popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
   
automaton.addTransition(from, inputString, to); automaton.addTransition(std::move(from), std::move(inputString), std::move(to));
} }
   
void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, ExtendedNFA& automaton) const { void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, ExtendedNFA& automaton) const {
...@@ -695,7 +695,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Exten ...@@ -695,7 +695,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Exten
State to = parseTransitionTo(input); State to = parseTransitionTo(input);
popToken(input, sax::Token::TokenType::END_ELEMENT, "transition"); popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
   
automaton.addTransition(from, inputRegexp, to); automaton.addTransition(std::move(from), std::move(inputRegexp), std::move(to));
} }
   
void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, DPDA& automaton) const { void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, DPDA& automaton) const {
...@@ -707,7 +707,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, DPDA& ...@@ -707,7 +707,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, DPDA&
std::vector<alphabet::Symbol> push = parseTransitionPush(input); std::vector<alphabet::Symbol> push = parseTransitionPush(input);
popToken(input, sax::Token::TokenType::END_ELEMENT, "transition"); popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
   
automaton.addTransition(from, inputSymbol, pop, to, push); automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(pop), std::move(to), std::move(push));
} }
   
void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, SinglePopDPDA& automaton) const { void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, SinglePopDPDA& automaton) const {
...@@ -719,7 +719,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Singl ...@@ -719,7 +719,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Singl
std::vector<alphabet::Symbol> push = parseTransitionPush(input); std::vector<alphabet::Symbol> push = parseTransitionPush(input);
popToken(input, sax::Token::TokenType::END_ELEMENT, "transition"); popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
   
automaton.addTransition(from, inputSymbol, pop, to, push); automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(pop), std::move(to), std::move(push));
} }
   
void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, InputDrivenDPDA& automaton) const { void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, InputDrivenDPDA& automaton) const {
...@@ -729,7 +729,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Input ...@@ -729,7 +729,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Input
State to = parseTransitionTo(input); State to = parseTransitionTo(input);
popToken(input, sax::Token::TokenType::END_ELEMENT, "transition"); popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
   
automaton.addTransition(from, inputSymbol, to); automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(to));
} }
   
void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, InputDrivenNPDA& automaton) const { void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, InputDrivenNPDA& automaton) const {
...@@ -739,7 +739,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Input ...@@ -739,7 +739,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Input
State to = parseTransitionTo(input); State to = parseTransitionTo(input);
popToken(input, sax::Token::TokenType::END_ELEMENT, "transition"); popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
   
automaton.addTransition(from, inputSymbol, to); automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(to));
} }
   
void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, VisiblyPushdownDPDA& automaton) const { void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, VisiblyPushdownDPDA& automaton) const {
...@@ -750,7 +750,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Visib ...@@ -750,7 +750,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Visib
State to = parseTransitionTo(input); State to = parseTransitionTo(input);
alphabet::Symbol push = parseTransitionSinglePush(input); alphabet::Symbol push = parseTransitionSinglePush(input);
   
automaton.addCallTransition(from, inputSymbol, to, push); automaton.addCallTransition(std::move(from), std::move(inputSymbol), std::move(to), std::move(push));
popToken(input, sax::Token::TokenType::END_ELEMENT, "callTransition"); popToken(input, sax::Token::TokenType::END_ELEMENT, "callTransition");
} else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition")) { } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition")) {
popToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition"); popToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition");
...@@ -759,7 +759,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Visib ...@@ -759,7 +759,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Visib
alphabet::Symbol pop = parseTransitionSinglePop(input); alphabet::Symbol pop = parseTransitionSinglePop(input);
State to = parseTransitionTo(input); State to = parseTransitionTo(input);
   
automaton.addReturnTransition(from, inputSymbol, pop, to); automaton.addReturnTransition(std::move(from), std::move(inputSymbol), std::move(pop), std::move(to));
popToken(input, sax::Token::TokenType::END_ELEMENT, "returnTransition"); popToken(input, sax::Token::TokenType::END_ELEMENT, "returnTransition");
} else { } else {
popToken(input, sax::Token::TokenType::START_ELEMENT, "localTransition"); popToken(input, sax::Token::TokenType::START_ELEMENT, "localTransition");
...@@ -767,7 +767,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Visib ...@@ -767,7 +767,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Visib
alphabet::Symbol inputSymbol = parseTransitionInputSymbol(input); alphabet::Symbol inputSymbol = parseTransitionInputSymbol(input);
State to = parseTransitionTo(input); State to = parseTransitionTo(input);
   
automaton.addLocalTransition(from, inputSymbol, to); automaton.addLocalTransition(std::move(from), std::move(inputSymbol), std::move(to));
popToken(input, sax::Token::TokenType::END_ELEMENT, "localTransition"); popToken(input, sax::Token::TokenType::END_ELEMENT, "localTransition");
} }
} }
...@@ -780,7 +780,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Visib ...@@ -780,7 +780,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Visib
State to = parseTransitionTo(input); State to = parseTransitionTo(input);
alphabet::Symbol push = parseTransitionSinglePush(input); alphabet::Symbol push = parseTransitionSinglePush(input);
   
automaton.addCallTransition(from, inputSymbol, to, push); automaton.addCallTransition(std::move(from), std::move(inputSymbol), std::move(to), std::move(push));
popToken(input, sax::Token::TokenType::END_ELEMENT, "callTransition"); popToken(input, sax::Token::TokenType::END_ELEMENT, "callTransition");
} else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition")) { } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition")) {
popToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition"); popToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition");
...@@ -789,7 +789,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Visib ...@@ -789,7 +789,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Visib
alphabet::Symbol pop = parseTransitionSinglePop(input); alphabet::Symbol pop = parseTransitionSinglePop(input);
State to = parseTransitionTo(input); State to = parseTransitionTo(input);
   
automaton.addReturnTransition(from, inputSymbol, pop, to); automaton.addReturnTransition(std::move(from), std::move(inputSymbol), std::move(pop), std::move(to));
popToken(input, sax::Token::TokenType::END_ELEMENT, "returnTransition"); popToken(input, sax::Token::TokenType::END_ELEMENT, "returnTransition");
} else { } else {
popToken(input, sax::Token::TokenType::START_ELEMENT, "localTransition"); popToken(input, sax::Token::TokenType::START_ELEMENT, "localTransition");
...@@ -797,7 +797,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Visib ...@@ -797,7 +797,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Visib
alphabet::Symbol inputSymbol = parseTransitionInputSymbol(input); alphabet::Symbol inputSymbol = parseTransitionInputSymbol(input);
State to = parseTransitionTo(input); State to = parseTransitionTo(input);
   
automaton.addLocalTransition(from, inputSymbol, to); automaton.addLocalTransition(std::move(from), std::move(inputSymbol), std::move(to));
popToken(input, sax::Token::TokenType::END_ELEMENT, "localTransition"); popToken(input, sax::Token::TokenType::END_ELEMENT, "localTransition");
} }
} }
...@@ -810,7 +810,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, RealT ...@@ -810,7 +810,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, RealT
State to = parseTransitionTo(input); State to = parseTransitionTo(input);
alphabet::Symbol push = parseTransitionSinglePush(input); alphabet::Symbol push = parseTransitionSinglePush(input);
   
automaton.addCallTransition(from, inputSymbol, to, push); automaton.addCallTransition(std::move(from), std::move(inputSymbol), std::move(to), std::move(push));
popToken(input, sax::Token::TokenType::END_ELEMENT, "callTransition"); popToken(input, sax::Token::TokenType::END_ELEMENT, "callTransition");
} else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition")) { } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition")) {
popToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition"); popToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition");
...@@ -819,7 +819,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, RealT ...@@ -819,7 +819,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, RealT
alphabet::Symbol pop = parseTransitionSinglePop(input); alphabet::Symbol pop = parseTransitionSinglePop(input);
State to = parseTransitionTo(input); State to = parseTransitionTo(input);
   
automaton.addReturnTransition(from, inputSymbol, pop, to); automaton.addReturnTransition(std::move(from), std::move(inputSymbol), std::move(pop), std::move(to));
popToken(input, sax::Token::TokenType::END_ELEMENT, "returnTransition"); popToken(input, sax::Token::TokenType::END_ELEMENT, "returnTransition");
} else { } else {
popToken(input, sax::Token::TokenType::START_ELEMENT, "localTransition"); popToken(input, sax::Token::TokenType::START_ELEMENT, "localTransition");
...@@ -827,7 +827,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, RealT ...@@ -827,7 +827,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, RealT
std::variant<string::Epsilon, alphabet::Symbol> inputSymbol = parseTransitionInputEpsilonSymbol(input); std::variant<string::Epsilon, alphabet::Symbol> inputSymbol = parseTransitionInputEpsilonSymbol(input);
State to = parseTransitionTo(input); State to = parseTransitionTo(input);
   
automaton.addLocalTransition(from, inputSymbol, to); automaton.addLocalTransition(std::move(from), std::move(inputSymbol), std::move(to));
popToken(input, sax::Token::TokenType::END_ELEMENT, "localTransition"); popToken(input, sax::Token::TokenType::END_ELEMENT, "localTransition");
} }
} }
...@@ -840,7 +840,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, RealT ...@@ -840,7 +840,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, RealT
State to = parseTransitionTo(input); State to = parseTransitionTo(input);
alphabet::Symbol push = parseTransitionSinglePush(input); alphabet::Symbol push = parseTransitionSinglePush(input);
   
automaton.addCallTransition(from, inputSymbol, to, push); automaton.addCallTransition(std::move(from), std::move(inputSymbol), std::move(to), std::move(push));
popToken(input, sax::Token::TokenType::END_ELEMENT, "callTransition"); popToken(input, sax::Token::TokenType::END_ELEMENT, "callTransition");
} else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition")) { } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition")) {
popToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition"); popToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition");
...@@ -849,7 +849,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, RealT ...@@ -849,7 +849,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, RealT
alphabet::Symbol pop = parseTransitionSinglePop(input); alphabet::Symbol pop = parseTransitionSinglePop(input);
State to = parseTransitionTo(input); State to = parseTransitionTo(input);
   
automaton.addReturnTransition(from, inputSymbol, pop, to); automaton.addReturnTransition(std::move(from), std::move(inputSymbol), std::move(pop), std::move(to));
popToken(input, sax::Token::TokenType::END_ELEMENT, "returnTransition"); popToken(input, sax::Token::TokenType::END_ELEMENT, "returnTransition");
} else { } else {
popToken(input, sax::Token::TokenType::START_ELEMENT, "localTransition"); popToken(input, sax::Token::TokenType::START_ELEMENT, "localTransition");
...@@ -857,7 +857,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, RealT ...@@ -857,7 +857,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, RealT
std::variant<string::Epsilon, alphabet::Symbol> inputSymbol = parseTransitionInputEpsilonSymbol(input); std::variant<string::Epsilon, alphabet::Symbol> inputSymbol = parseTransitionInputEpsilonSymbol(input);
State to = parseTransitionTo(input); State to = parseTransitionTo(input);
   
automaton.addLocalTransition(from, inputSymbol, to); automaton.addLocalTransition(std::move(from), std::move(inputSymbol), std::move(to));
popToken(input, sax::Token::TokenType::END_ELEMENT, "localTransition"); popToken(input, sax::Token::TokenType::END_ELEMENT, "localTransition");
} }
} }
...@@ -871,7 +871,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, NPDA& ...@@ -871,7 +871,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, NPDA&
std::vector<alphabet::Symbol> push = parseTransitionPush(input); std::vector<alphabet::Symbol> push = parseTransitionPush(input);
popToken(input, sax::Token::TokenType::END_ELEMENT, "transition"); popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
   
automaton.addTransition(from, inputSymbol, pop, to, push); automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(pop), std::move(to), std::move(push));
} }
   
void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, SinglePopNPDA& automaton) const { void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, SinglePopNPDA& automaton) const {
...@@ -883,7 +883,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Singl ...@@ -883,7 +883,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Singl
std::vector<alphabet::Symbol> push = parseTransitionPush(input); std::vector<alphabet::Symbol> push = parseTransitionPush(input);
popToken(input, sax::Token::TokenType::END_ELEMENT, "transition"); popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
   
automaton.addTransition(from, inputSymbol, pop, to, push); automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(pop), std::move(to), std::move(push));
} }
   
void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, OneTapeDTM& automaton) const { void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, OneTapeDTM& automaton) const {
...@@ -895,7 +895,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, OneTa ...@@ -895,7 +895,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, OneTa
Shift shift = parseTransitionShift(input); Shift shift = parseTransitionShift(input);
popToken(input, sax::Token::TokenType::END_ELEMENT, "transition"); popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
   
automaton.addTransition(from, inputSymbol, to, outputSymbol, shift); automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(to), std::move(outputSymbol), shift);
} }
   
State AutomatonFromXMLParser::parseTransitionTo(std::list<sax::Token> &input) const { State AutomatonFromXMLParser::parseTransitionTo(std::list<sax::Token> &input) const {
......
alib2data/src/container/ContainerFromXMLParser.cpp
+ 1
− 1
View file @ d6da4a44
...@@ -72,7 +72,7 @@ ObjectsPair ContainerFromXMLParser::parseObjectsPair(std::list<sax::Token>& inpu ...@@ -72,7 +72,7 @@ ObjectsPair ContainerFromXMLParser::parseObjectsPair(std::list<sax::Token>& inpu
alib::Object first = alib::xmlApi<alib::Object>::parse(input); alib::Object first = alib::xmlApi<alib::Object>::parse(input);
alib::Object second = alib::xmlApi<alib::Object>::parse(input); alib::Object second = alib::xmlApi<alib::Object>::parse(input);
   
ObjectsPair pair(first, second); ObjectsPair pair(std::move(first), std::move(second));
   
popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::CONTAINER_OBJECTS_PAIR); popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::CONTAINER_OBJECTS_PAIR);
return pair; return pair;
......
alib2data/src/container/ContainerFromXMLParser.hpp
+ 1
− 1
View file @ d6da4a44
...@@ -108,7 +108,7 @@ std::pair<T, R> ContainerFromXMLParser::parsePair(std::list<sax::Token>& input) ...@@ -108,7 +108,7 @@ std::pair<T, R> ContainerFromXMLParser::parsePair(std::list<sax::Token>& input)
R second = alib::xmlApi<R>::parse(input); R second = alib::xmlApi<R>::parse(input);
   
popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::CONTAINER_OBJECTS_PAIR); popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::CONTAINER_OBJECTS_PAIR);
return std::make_pair(first, second); return std::make_pair(std::move(first), std::move(second));
} }
   
template<typename T, typename R> template<typename T, typename R>
......
alib2data/src/exception/ExceptionFromXMLParser.cpp
+ 1
− 1
View file @ d6da4a44
...@@ -35,7 +35,7 @@ AlibException ExceptionFromXMLParser::parseException(std::list<sax::Token>& inpu ...@@ -35,7 +35,7 @@ AlibException ExceptionFromXMLParser::parseException(std::list<sax::Token>& inpu
} }
popToken(input, sax::Token::TokenType::END_ELEMENT, "backtrace"); popToken(input, sax::Token::TokenType::END_ELEMENT, "backtrace");
popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::EXCEPTION_ALIB_EXCEPTION); popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::EXCEPTION_ALIB_EXCEPTION);
return AlibException(cause, backtrace); return AlibException(std::move(cause), std::move(backtrace));
} }
   
bool ExceptionFromXMLParser::first(const std::list<sax::Token>& input) const { bool ExceptionFromXMLParser::first(const std::list<sax::Token>& input) const {
......
alib2data/src/grammar/GrammarFromXMLParser.cpp
+ 55
− 55
View file @ d6da4a44
...@@ -77,9 +77,9 @@ UnrestrictedGrammar GrammarFromXMLParser::parseUnrestrictedGrammar(std::list<sax ...@@ -77,9 +77,9 @@ UnrestrictedGrammar GrammarFromXMLParser::parseUnrestrictedGrammar(std::list<sax
std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input); std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
alphabet::Symbol initialSymbol = parseInitialSymbol(input); alphabet::Symbol initialSymbol = parseInitialSymbol(input);
   
UnrestrictedGrammar grammar(initialSymbol); UnrestrictedGrammar grammar(std::move(initialSymbol));
grammar.setNonterminalAlphabet(nonterminalAlphabet); grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
grammar.setTerminalAlphabet(terminalAlphabet); grammar.setTerminalAlphabet(std::move(terminalAlphabet));
   
parseRules(input, grammar); parseRules(input, grammar);
   
...@@ -94,9 +94,9 @@ ContextPreservingUnrestrictedGrammar GrammarFromXMLParser::parseContextPreservin ...@@ -94,9 +94,9 @@ ContextPreservingUnrestrictedGrammar GrammarFromXMLParser::parseContextPreservin
std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input); std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
alphabet::Symbol initialSymbol = parseInitialSymbol(input); alphabet::Symbol initialSymbol = parseInitialSymbol(input);
   
ContextPreservingUnrestrictedGrammar grammar(initialSymbol); ContextPreservingUnrestrictedGrammar grammar(std::move(initialSymbol));
grammar.setNonterminalAlphabet(nonterminalAlphabet); grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
grammar.setTerminalAlphabet(terminalAlphabet); grammar.setTerminalAlphabet(std::move(terminalAlphabet));
   
parseRules(input, grammar); parseRules(input, grammar);
   
...@@ -111,9 +111,9 @@ NonContractingGrammar GrammarFromXMLParser::parseNonContractingGrammar(std::list ...@@ -111,9 +111,9 @@ NonContractingGrammar GrammarFromXMLParser::parseNonContractingGrammar(std::list
std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input); std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
alphabet::Symbol initialSymbol = parseInitialSymbol(input); alphabet::Symbol initialSymbol = parseInitialSymbol(input);
   
NonContractingGrammar grammar(initialSymbol); NonContractingGrammar grammar(std::move(initialSymbol));
grammar.setNonterminalAlphabet(nonterminalAlphabet); grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
grammar.setTerminalAlphabet(terminalAlphabet); grammar.setTerminalAlphabet(std::move(terminalAlphabet));
   
parseRules(input, grammar); parseRules(input, grammar);
   
...@@ -131,9 +131,9 @@ CSG GrammarFromXMLParser::parseCSG(std::list<sax::Token>& input) const { ...@@ -131,9 +131,9 @@ CSG GrammarFromXMLParser::parseCSG(std::list<sax::Token>& input) const {
std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input); std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
alphabet::Symbol initialSymbol = parseInitialSymbol(input); alphabet::Symbol initialSymbol = parseInitialSymbol(input);
   
CSG grammar(initialSymbol); CSG grammar(std::move(initialSymbol));
grammar.setNonterminalAlphabet(nonterminalAlphabet); grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
grammar.setTerminalAlphabet(terminalAlphabet); grammar.setTerminalAlphabet(std::move(terminalAlphabet));
   
parseRules(input, grammar); parseRules(input, grammar);
   
...@@ -151,9 +151,9 @@ GNF GrammarFromXMLParser::parseGNF(std::list<sax::Token>& input) const { ...@@ -151,9 +151,9 @@ GNF GrammarFromXMLParser::parseGNF(std::list<sax::Token>& input) const {
std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input); std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
alphabet::Symbol initialSymbol = parseInitialSymbol(input); alphabet::Symbol initialSymbol = parseInitialSymbol(input);
   
GNF grammar(initialSymbol); GNF grammar(std::move(initialSymbol));
grammar.setNonterminalAlphabet(nonterminalAlphabet); grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
grammar.setTerminalAlphabet(terminalAlphabet); grammar.setTerminalAlphabet(std::move(terminalAlphabet));
   
parseRules(input, grammar); parseRules(input, grammar);
   
...@@ -171,9 +171,9 @@ CNF GrammarFromXMLParser::parseCNF(std::list<sax::Token>& input) const { ...@@ -171,9 +171,9 @@ CNF GrammarFromXMLParser::parseCNF(std::list<sax::Token>& input) const {
std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input); std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
alphabet::Symbol initialSymbol = parseInitialSymbol(input); alphabet::Symbol initialSymbol = parseInitialSymbol(input);
   
CNF grammar(initialSymbol); CNF grammar(std::move(initialSymbol));
grammar.setNonterminalAlphabet(nonterminalAlphabet); grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
grammar.setTerminalAlphabet(terminalAlphabet); grammar.setTerminalAlphabet(std::move(terminalAlphabet));
   
parseRules(input, grammar); parseRules(input, grammar);
   
...@@ -191,9 +191,9 @@ EpsilonFreeCFG GrammarFromXMLParser::parseEpsilonFreeCFG(std::list<sax::Token>& ...@@ -191,9 +191,9 @@ EpsilonFreeCFG GrammarFromXMLParser::parseEpsilonFreeCFG(std::list<sax::Token>&
std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input); std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
alphabet::Symbol initialSymbol = parseInitialSymbol(input); alphabet::Symbol initialSymbol = parseInitialSymbol(input);
   
EpsilonFreeCFG grammar(initialSymbol); EpsilonFreeCFG grammar(std::move(initialSymbol));
grammar.setNonterminalAlphabet(nonterminalAlphabet); grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
grammar.setTerminalAlphabet(terminalAlphabet); grammar.setTerminalAlphabet(std::move(terminalAlphabet));
   
parseRules(input, grammar); parseRules(input, grammar);
   
...@@ -211,9 +211,9 @@ CFG GrammarFromXMLParser::parseCFG(std::list<sax::Token>& input) const { ...@@ -211,9 +211,9 @@ CFG GrammarFromXMLParser::parseCFG(std::list<sax::Token>& input) const {
std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input); std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
alphabet::Symbol initialSymbol = parseInitialSymbol(input); alphabet::Symbol initialSymbol = parseInitialSymbol(input);
   
CFG grammar(initialSymbol); CFG grammar(std::move(initialSymbol));
grammar.setNonterminalAlphabet(nonterminalAlphabet); grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
grammar.setTerminalAlphabet(terminalAlphabet); grammar.setTerminalAlphabet(std::move(terminalAlphabet));
   
parseRules(input, grammar); parseRules(input, grammar);
   
...@@ -228,9 +228,9 @@ LG GrammarFromXMLParser::parseLG(std::list<sax::Token>& input) const { ...@@ -228,9 +228,9 @@ LG GrammarFromXMLParser::parseLG(std::list<sax::Token>& input) const {
std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input); std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
alphabet::Symbol initialSymbol = parseInitialSymbol(input); alphabet::Symbol initialSymbol = parseInitialSymbol(input);
   
LG grammar(initialSymbol); LG grammar(std::move(initialSymbol));
grammar.setNonterminalAlphabet(nonterminalAlphabet); grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
grammar.setTerminalAlphabet(terminalAlphabet); grammar.setTerminalAlphabet(std::move(terminalAlphabet));
   
parseRules(input, grammar); parseRules(input, grammar);
   
...@@ -245,9 +245,9 @@ RightRG GrammarFromXMLParser::parseRightRG(std::list<sax::Token>& input) const { ...@@ -245,9 +245,9 @@ RightRG GrammarFromXMLParser::parseRightRG(std::list<sax::Token>& input) const {
std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input); std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
alphabet::Symbol initialSymbol = parseInitialSymbol(input); alphabet::Symbol initialSymbol = parseInitialSymbol(input);
   
RightRG grammar(initialSymbol); RightRG grammar(std::move(initialSymbol));
grammar.setNonterminalAlphabet(nonterminalAlphabet); grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
grammar.setTerminalAlphabet(terminalAlphabet); grammar.setTerminalAlphabet(std::move(terminalAlphabet));
   
parseRules(input, grammar); parseRules(input, grammar);
   
...@@ -265,9 +265,9 @@ RightLG GrammarFromXMLParser::parseRightLG(std::list<sax::Token>& input) const { ...@@ -265,9 +265,9 @@ RightLG GrammarFromXMLParser::parseRightLG(std::list<sax::Token>& input) const {
std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input); std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
alphabet::Symbol initialSymbol = parseInitialSymbol(input); alphabet::Symbol initialSymbol = parseInitialSymbol(input);
   
RightLG grammar(initialSymbol); RightLG grammar(std::move(initialSymbol));
grammar.setNonterminalAlphabet(nonterminalAlphabet); grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
grammar.setTerminalAlphabet(terminalAlphabet); grammar.setTerminalAlphabet(std::move(terminalAlphabet));
   
parseRules(input, grammar); parseRules(input, grammar);
   
...@@ -282,9 +282,9 @@ LeftRG GrammarFromXMLParser::parseLeftRG(std::list<sax::Token>& input) const { ...@@ -282,9 +282,9 @@ LeftRG GrammarFromXMLParser::parseLeftRG(std::list<sax::Token>& input) const {
std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input); std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
alphabet::Symbol initialSymbol = parseInitialSymbol(input); alphabet::Symbol initialSymbol = parseInitialSymbol(input);
   
LeftRG grammar(initialSymbol); LeftRG grammar(std::move(initialSymbol));
grammar.setNonterminalAlphabet(nonterminalAlphabet); grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
grammar.setTerminalAlphabet(terminalAlphabet); grammar.setTerminalAlphabet(std::move(terminalAlphabet));
   
parseRules(input, grammar); parseRules(input, grammar);
   
...@@ -302,9 +302,9 @@ LeftLG GrammarFromXMLParser::parseLeftLG(std::list<sax::Token>& input) const { ...@@ -302,9 +302,9 @@ LeftLG GrammarFromXMLParser::parseLeftLG(std::list<sax::Token>& input) const {
std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input); std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
alphabet::Symbol initialSymbol = parseInitialSymbol(input); alphabet::Symbol initialSymbol = parseInitialSymbol(input);
   
LeftLG grammar(initialSymbol); LeftLG grammar(std::move(initialSymbol));
grammar.setNonterminalAlphabet(nonterminalAlphabet); grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
grammar.setTerminalAlphabet(terminalAlphabet); grammar.setTerminalAlphabet(std::move(terminalAlphabet));
   
parseRules(input, grammar); parseRules(input, grammar);
   
...@@ -370,7 +370,7 @@ void GrammarFromXMLParser::parseRules(std::list<sax::Token> &input, T& grammar) ...@@ -370,7 +370,7 @@ void GrammarFromXMLParser::parseRules(std::list<sax::Token> &input, T& grammar)
void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, UnrestrictedGrammar& grammar) const { void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, UnrestrictedGrammar& grammar) const {
std::vector<alphabet::Symbol> lhs = parseRuleLHS(input); std::vector<alphabet::Symbol> lhs = parseRuleLHS(input);
std::vector<alphabet::Symbol> rhs = parseRuleRHS(input); std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
grammar.addRule(lhs, rhs); grammar.addRule(std::move(lhs), std::move(rhs));
} }
   
void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, ContextPreservingUnrestrictedGrammar& grammar) const { void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, ContextPreservingUnrestrictedGrammar& grammar) const {
...@@ -378,13 +378,13 @@ void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, ContextPreser ...@@ -378,13 +378,13 @@ void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, ContextPreser
alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input); alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
std::vector<alphabet::Symbol> rContext = parseRuleRContext(input); std::vector<alphabet::Symbol> rContext = parseRuleRContext(input);
std::vector<alphabet::Symbol> rhs = parseRuleRHS(input); std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
grammar.addRule(lContext, lhs, rContext, rhs); grammar.addRule(std::move(lContext), std::move(lhs), std::move(rContext), std::move(rhs));
} }
   
void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, NonContractingGrammar& grammar) const { void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, NonContractingGrammar& grammar) const {
std::vector<alphabet::Symbol> lhs = parseRuleLHS(input); std::vector<alphabet::Symbol> lhs = parseRuleLHS(input);
std::vector<alphabet::Symbol> rhs = parseRuleRHS(input); std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
grammar.addRule(lhs, rhs); grammar.addRule(std::move(lhs), std::move(rhs));
} }
   
void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, CSG& grammar) const { void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, CSG& grammar) const {
...@@ -392,61 +392,61 @@ void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, CSG& grammar) ...@@ -392,61 +392,61 @@ void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, CSG& grammar)
alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input); alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
std::vector<alphabet::Symbol> rContext = parseRuleRContext(input); std::vector<alphabet::Symbol> rContext = parseRuleRContext(input);
std::vector<alphabet::Symbol> rhs = parseRuleRHS(input); std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
grammar.addRule(lContext, lhs, rContext, rhs); grammar.addRule(std::move(lContext), std::move(lhs), std::move(rContext), std::move(rhs));
} }
   
void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, GNF& grammar) const { void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, GNF& grammar) const {
alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input); alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>> rhs = parseRuleGNFRHS(input); std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>> rhs = parseRuleGNFRHS(input);
grammar.addRule(lhs, rhs); grammar.addRule(std::move(lhs), std::move(rhs));
} }
   
void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, CNF& grammar) const { void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, CNF& grammar) const {
alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input); alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> rhs = parseRuleOneOrTwoSymbolsRHS(input); std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> rhs = parseRuleOneOrTwoSymbolsRHS(input);
grammar.addRule(lhs, rhs); grammar.addRule(std::move(lhs), std::move(rhs));
} }
   
void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, EpsilonFreeCFG& grammar) const { void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, EpsilonFreeCFG& grammar) const {
alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input); alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
std::vector<alphabet::Symbol> rhs = parseRuleRHS(input); std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
grammar.addRule(lhs, rhs); grammar.addRule(std::move(lhs), std::move(rhs));
} }
   
void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, CFG& grammar) const { void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, CFG& grammar) const {
alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input); alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
std::vector<alphabet::Symbol> rhs = parseRuleRHS(input); std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
grammar.addRule(lhs, rhs); grammar.addRule(std::move(lhs), std::move(rhs));
} }
   
void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, LG& grammar) const { void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, LG& grammar) const {
alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input); alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
std::vector<alphabet::Symbol> rhs = parseRuleRHS(input); std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
grammar.addRawRule(lhs, rhs); grammar.addRawRule(std::move(lhs), std::move(rhs));
} }
   
void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, RightRG& grammar) const { void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, RightRG& grammar) const {
alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input); alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> rhs = parseRuleOneOrTwoSymbolsRHS(input); std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> rhs = parseRuleOneOrTwoSymbolsRHS(input);
grammar.addRule(lhs, rhs); grammar.addRule(std::move(lhs), std::move(rhs));
} }
   
void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, RightLG& grammar) const { void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, RightLG& grammar) const {
alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input); alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
std::vector<alphabet::Symbol> rhs = parseRuleRHS(input); std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
grammar.addRawRule(lhs, rhs); grammar.addRawRule(std::move(lhs), std::move(rhs));
} }
   
void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, LeftRG& grammar) const { void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, LeftRG& grammar) const {
alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input); alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> rhs = parseRuleOneOrTwoSymbolsRHS(input); std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> rhs = parseRuleOneOrTwoSymbolsRHS(input);
grammar.addRule(lhs, rhs); grammar.addRule(std::move(lhs), std::move(rhs));
} }
   
void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, LeftLG& grammar) const { void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, LeftLG& grammar) const {
alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input); alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
std::vector<alphabet::Symbol> rhs = parseRuleRHS(input); std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
grammar.addRawRule(lhs, rhs); grammar.addRawRule(std::move(lhs), std::move(rhs));
} }
   
   
...@@ -504,7 +504,7 @@ std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>> GrammarFromXMLParser: ...@@ -504,7 +504,7 @@ std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>> GrammarFromXMLParser:
second.push_back(alib::xmlApi<alphabet::Symbol>::parse(input)); second.push_back(alib::xmlApi<alphabet::Symbol>::parse(input));
} }
popToken(input, sax::Token::TokenType::END_ELEMENT, "rhs"); popToken(input, sax::Token::TokenType::END_ELEMENT, "rhs");
return std::make_pair(first, second); return std::make_pair(std::move(first), std::move(second));
} }
   
std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleRHS(std::list<sax::Token>& input) const { std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleRHS(std::list<sax::Token>& input) const {
...@@ -526,10 +526,10 @@ std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> Gr ...@@ -526,10 +526,10 @@ std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> Gr
if(isTokenType(input, sax::Token::TokenType::START_ELEMENT)) { if(isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
alphabet::Symbol second = alib::xmlApi<alphabet::Symbol>::parse(input); alphabet::Symbol second = alib::xmlApi<alphabet::Symbol>::parse(input);
popToken(input, sax::Token::TokenType::END_ELEMENT, "rhs"); popToken(input, sax::Token::TokenType::END_ELEMENT, "rhs");
return std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>>(std::make_pair(first, second)); return std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>>(std::make_pair(std::move(first), std::move(second)));
} else { } else {
popToken(input, sax::Token::TokenType::END_ELEMENT, "rhs"); popToken(input, sax::Token::TokenType::END_ELEMENT, "rhs");
return std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>>(first); return std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>>(std::move(first));
} }
} }
   
......
alib2data/src/graph/GraphFromXMLParser.cpp
+ 5
− 5
View file @ d6da4a44
...@@ -88,7 +88,7 @@ DirectedEdge GraphFromXMLParser::parseDirectedEdge(std::list<sax::Token> &input) ...@@ -88,7 +88,7 @@ DirectedEdge GraphFromXMLParser::parseDirectedEdge(std::list<sax::Token> &input)
popToken(input, sax::Token::TokenType::END_ELEMENT, "to"); popToken(input, sax::Token::TokenType::END_ELEMENT, "to");
   
popToken(input, sax::Token::TokenType::END_ELEMENT, "edge"); popToken(input, sax::Token::TokenType::END_ELEMENT, "edge");
return DirectedEdge(from, to, name); return DirectedEdge(std::move(from), std::move(to), std::move(name));
} }
   
UndirectedEdge GraphFromXMLParser::parseUndirectedEdge(std::list<sax::Token> &input) const UndirectedEdge GraphFromXMLParser::parseUndirectedEdge(std::list<sax::Token> &input) const
...@@ -106,7 +106,7 @@ UndirectedEdge GraphFromXMLParser::parseUndirectedEdge(std::list<sax::Token> &in ...@@ -106,7 +106,7 @@ UndirectedEdge GraphFromXMLParser::parseUndirectedEdge(std::list<sax::Token> &in
popToken(input, sax::Token::TokenType::END_ELEMENT, "second"); popToken(input, sax::Token::TokenType::END_ELEMENT, "second");
   
popToken(input, sax::Token::TokenType::END_ELEMENT, "edge"); popToken(input, sax::Token::TokenType::END_ELEMENT, "edge");
return UndirectedEdge(first, second, name); return UndirectedEdge(std::move(first), std::move(second), std::move(name));
} }
   
int GraphFromXMLParser::parseValue(std::list<sax::Token> &input) const int GraphFromXMLParser::parseValue(std::list<sax::Token> &input) const
...@@ -162,7 +162,7 @@ void GraphFromXMLParser::parseNodeValues(std::list<sax::Token> &input, T &graph) ...@@ -162,7 +162,7 @@ void GraphFromXMLParser::parseNodeValues(std::list<sax::Token> &input, T &graph)
graph::Node node = parseNode(input); graph::Node node = parseNode(input);
int value = parseValue(input); int value = parseValue(input);
   
graph.setNodeValue(node, value); graph.setNodeValue(std::move(node), value);
} }
   
popToken(input, sax::Token::TokenType::END_ELEMENT, "nodevalues"); popToken(input, sax::Token::TokenType::END_ELEMENT, "nodevalues");
...@@ -176,7 +176,7 @@ void GraphFromXMLParser::parseDirectedEdgeValues(std::list<sax::Token> &input, D ...@@ -176,7 +176,7 @@ void GraphFromXMLParser::parseDirectedEdgeValues(std::list<sax::Token> &input, D
graph::DirectedEdge edge = parseDirectedEdge(input); graph::DirectedEdge edge = parseDirectedEdge(input);
int value = parseValue(input); int value = parseValue(input);
   
graph.setEdgeValue(edge, value); graph.setEdgeValue(std::move(edge), value);
} }
   
popToken(input, sax::Token::TokenType::END_ELEMENT, "edgevalues"); popToken(input, sax::Token::TokenType::END_ELEMENT, "edgevalues");
...@@ -190,7 +190,7 @@ void GraphFromXMLParser::parseUndirectedEdgeValues(std::list<sax::Token> &input, ...@@ -190,7 +190,7 @@ void GraphFromXMLParser::parseUndirectedEdgeValues(std::list<sax::Token> &input,
graph::UndirectedEdge edge = parseUndirectedEdge(input); graph::UndirectedEdge edge = parseUndirectedEdge(input);
int value = parseValue(input); int value = parseValue(input);
   
graph.setEdgeValue(edge, value); graph.setEdgeValue(std::move(edge), value);
} }
   
popToken(input, sax::Token::TokenType::END_ELEMENT, "edgevalues"); popToken(input, sax::Token::TokenType::END_ELEMENT, "edgevalues");
......
alib2data/src/label/LabelFromXMLParser.cpp
+ 3
− 3
View file @ d6da4a44
...@@ -75,7 +75,7 @@ LabelSetLabel LabelFromXMLParser::parseLabelSetLabel(std::list<sax::Token>& inpu ...@@ -75,7 +75,7 @@ LabelSetLabel LabelFromXMLParser::parseLabelSetLabel(std::list<sax::Token>& inpu
while(isTokenType(input, sax::Token::TokenType::START_ELEMENT)) { while(isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
labels.insert(parseLabel(input)); labels.insert(parseLabel(input));
} }
LabelSetLabel data(labels); LabelSetLabel data(std::move(labels));
popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::LABEL_LABEL_SET_LABEL); popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::LABEL_LABEL_SET_LABEL);
return data; return data;
} }
...@@ -86,7 +86,7 @@ LabelPairLabel LabelFromXMLParser::parseLabelPairLabel(std::list<sax::Token>& in ...@@ -86,7 +86,7 @@ LabelPairLabel LabelFromXMLParser::parseLabelPairLabel(std::list<sax::Token>& in
Label firstLabel = parseLabel(input); Label firstLabel = parseLabel(input);
Label secondLabel = parseLabel(input); Label secondLabel = parseLabel(input);
   
LabelPairLabel data(std::make_pair(firstLabel, secondLabel)); LabelPairLabel data(std::make_pair(std::move(firstLabel), std::move(secondLabel)));
popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::LABEL_LABEL_PAIR_LABEL); popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::LABEL_LABEL_PAIR_LABEL);
return data; return data;
} }
...@@ -97,7 +97,7 @@ UniqueLabel LabelFromXMLParser::parseUniqueLabel(std::list<sax::Token>& input) c ...@@ -97,7 +97,7 @@ UniqueLabel LabelFromXMLParser::parseUniqueLabel(std::list<sax::Token>& input) c
Label firstLabel = parseLabel(input); Label firstLabel = parseLabel(input);
primitive::Integer secondLabel = alib::xmlApi<primitive::Integer>::parse(input); primitive::Integer secondLabel = alib::xmlApi<primitive::Integer>::parse(input);
   
UniqueLabel data(firstLabel, secondLabel); UniqueLabel data(std::move(firstLabel), std::move(secondLabel));
popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::LABEL_UNIQUE_LABEL); popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::LABEL_UNIQUE_LABEL);
return data; return data;
} }
......
alib2data/src/label/UniqueLabel.cpp
+ 5
− 1
View file @ d6da4a44
...@@ -11,7 +11,11 @@ ...@@ -11,7 +11,11 @@
   
namespace label { namespace label {
   
UniqueLabel::UniqueLabel(const Label& label, primitive::Integer& id) : label(label), id(id) { UniqueLabel::UniqueLabel(const Label& label, const primitive::Integer& id) : label(label), id(id) {
}
UniqueLabel::UniqueLabel(Label&& label, primitive::Integer&& id) : label(std::move(label)), id(std::move(id)) {
   
} }
   
......
alib2data/src/label/UniqueLabel.h
+ 3
− 1
View file @ d6da4a44
...@@ -31,7 +31,9 @@ public: ...@@ -31,7 +31,9 @@ public:
* Creates new symbol with given name. * Creates new symbol with given name.
* @param symbol name of the symbol * @param symbol name of the symbol
*/ */
explicit UniqueLabel(const Label& label, primitive::Integer& id); explicit UniqueLabel(const Label& label, const primitive::Integer& id);
explicit UniqueLabel(Label&& label, primitive::Integer&& id);
   
virtual LabelBase* clone() const; virtual LabelBase* clone() const;
   
......
alib2data/src/primitive/PrimitiveFromXMLParser.cpp
+ 1
− 1
View file @ d6da4a44
...@@ -67,7 +67,7 @@ String PrimitiveFromXMLParser::parseString(std::list<sax::Token>& input) const { ...@@ -67,7 +67,7 @@ String PrimitiveFromXMLParser::parseString(std::list<sax::Token>& input) const {
if( isTokenType(input, sax::Token::TokenType::CHARACTER)) if( isTokenType(input, sax::Token::TokenType::CHARACTER))
data = popTokenData(input, sax::Token::TokenType::CHARACTER); data = popTokenData(input, sax::Token::TokenType::CHARACTER);
popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::PRIMITIVE_STRING); popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::PRIMITIVE_STRING);
return String(data); return String(std::move(data));
} }
   
Unsigned PrimitiveFromXMLParser::parseUnsigned(std::list<sax::Token>& input) const { Unsigned PrimitiveFromXMLParser::parseUnsigned(std::list<sax::Token>& input) const {
......
alib2data/src/regexp/RegExpFromXMLParser.cpp
+ 1
− 1
View file @ d6da4a44
...@@ -176,7 +176,7 @@ FormalRegExpAlternation* RegExpFromXMLParser::parseFormalRegExpAlternation(std:: ...@@ -176,7 +176,7 @@ FormalRegExpAlternation* RegExpFromXMLParser::parseFormalRegExpAlternation(std::
   
FormalRegExpElement* element1 = parseFormalRegExpElement(input); FormalRegExpElement* element1 = parseFormalRegExpElement(input);
FormalRegExpElement* element2 = parseFormalRegExpElement(input); FormalRegExpElement* element2 = parseFormalRegExpElement(input);
FormalRegExpAlternation* alternation = new FormalRegExpAlternation(std::move(*element1), std::move(*element2)); FormalRegExpAlternation* alternation = new FormalRegExpAlternation(std::move(*element1), std::move(*element2));
   
delete element1; delete element1;
......
alib2data/src/string/StringFromXMLParser.cpp
+ 5
− 12
View file @ d6da4a44
...@@ -43,11 +43,8 @@ LinearString StringFromXMLParser::parseLinearString(std::list<sax::Token>& input ...@@ -43,11 +43,8 @@ LinearString StringFromXMLParser::parseLinearString(std::list<sax::Token>& input
popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::STRING_LINEAR_STRING); popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::STRING_LINEAR_STRING);
   
LinearString string; LinearString string;
std::set<alphabet::Symbol> alphabet = parseAlphabet(input); string.setAlphabet(parseAlphabet(input));
string.setAlphabet(alphabet); string.setContent(parseContentData(input));
std::vector<alphabet::Symbol> data = parseContentData(input);
string.setContent(data);
   
popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::STRING_LINEAR_STRING); popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::STRING_LINEAR_STRING);
return string; return string;
...@@ -57,11 +54,8 @@ CyclicString StringFromXMLParser::parseCyclicString(std::list<sax::Token>& input ...@@ -57,11 +54,8 @@ CyclicString StringFromXMLParser::parseCyclicString(std::list<sax::Token>& input
popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::STRING_CYCLIC_STRING); popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::STRING_CYCLIC_STRING);
   
CyclicString string; CyclicString string;
std::set<alphabet::Symbol> alphabet = parseAlphabet(input); string.setAlphabet(parseAlphabet(input));
string.setAlphabet(alphabet); string.setContent(parseContentData(input));
std::vector<alphabet::Symbol> data = parseContentData(input);
string.setContent(data);
   
popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::STRING_CYCLIC_STRING); popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::STRING_CYCLIC_STRING);
return string; return string;
...@@ -71,8 +65,7 @@ Epsilon StringFromXMLParser::parseEpsilon(std::list<sax::Token>& input) const { ...@@ -71,8 +65,7 @@ Epsilon StringFromXMLParser::parseEpsilon(std::list<sax::Token>& input) const {
popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::STRING_EPSILON); popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::STRING_EPSILON);
   
Epsilon epsilon; Epsilon epsilon;
std::set<alphabet::Symbol> alphabet = parseAlphabet(input); epsilon.setAlphabet(parseAlphabet(input));
epsilon.setAlphabet(alphabet);
   
popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::STRING_EPSILON); popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::STRING_EPSILON);
return epsilon; return epsilon;
......
alib2data/test-src/grammar/GrammarTest.cpp
+ 2
− 0
View file @ d6da4a44
...@@ -206,6 +206,8 @@ void GrammarTest::testRegularParser() { ...@@ -206,6 +206,8 @@ void GrammarTest::testRegularParser() {
std::string tmp; std::string tmp;
sax::SaxComposeInterface::printMemory(tmp, tokens); sax::SaxComposeInterface::printMemory(tmp, tokens);
   
std::cout << tmp << std::endl;
std::list<sax::Token> tokens2; std::list<sax::Token> tokens2;
sax::SaxParseInterface::parseMemory(tmp, tokens2); sax::SaxParseInterface::parseMemory(tmp, tokens2);
grammar::RightLG grammar2 = alib::XmlDataFactory::fromTokens<grammar::RightLG>(tokens2); grammar::RightLG grammar2 = alib::XmlDataFactory::fromTokens<grammar::RightLG>(tokens2);
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment