diff --git a/alib2data/src/alphabet/SymbolToXMLComposer.cpp b/alib2data/src/alphabet/SymbolToXMLComposer.cpp
index fd984eaf9d39cf7b796456db3ed1bba1ff752bfe..2bd45e093723adfe0e12602bf89632f4554d95c4 100644
--- a/alib2data/src/alphabet/SymbolToXMLComposer.cpp
+++ b/alib2data/src/alphabet/SymbolToXMLComposer.cpp
@@ -20,74 +20,74 @@ void SymbolToXMLComposer::compose(std::deque<sax::Token>& out, const SymbolBase&
 }
 
 void SymbolToXMLComposer::compose(std::deque<sax::Token>& out, const LabeledSymbol& symbol) const {
-	out.push_back(sax::Token(alib::Names::ALPHABET_LABELED_SYMBOL, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::ALPHABET_LABELED_SYMBOL, sax::Token::TokenType::START_ELEMENT);
 	alib::xmlApi<label::Label>::compose(out, symbol.getLabel());
-	out.push_back(sax::Token(alib::Names::ALPHABET_LABELED_SYMBOL, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::ALPHABET_LABELED_SYMBOL, sax::Token::TokenType::END_ELEMENT);
 }
 
 void SymbolToXMLComposer::compose(std::deque<sax::Token>& out, const BlankSymbol&) const {
-	out.push_back(sax::Token(alib::Names::ALPHABET_BLANK_SYMBOL, sax::Token::TokenType::START_ELEMENT));
-	out.push_back(sax::Token(alib::Names::ALPHABET_BLANK_SYMBOL, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::ALPHABET_BLANK_SYMBOL, sax::Token::TokenType::START_ELEMENT);
+	out.emplace_back(alib::Names::ALPHABET_BLANK_SYMBOL, sax::Token::TokenType::END_ELEMENT);
 }
 
 void SymbolToXMLComposer::compose(std::deque<sax::Token>& out, const BottomOfTheStackSymbol&) const {
-	out.push_back(sax::Token(alib::Names::ALPHABET_BOTTOM_OF_THE_STACK_SYMBOL, sax::Token::TokenType::START_ELEMENT));
-	out.push_back(sax::Token(alib::Names::ALPHABET_BOTTOM_OF_THE_STACK_SYMBOL, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::ALPHABET_BOTTOM_OF_THE_STACK_SYMBOL, sax::Token::TokenType::START_ELEMENT);
+	out.emplace_back(alib::Names::ALPHABET_BOTTOM_OF_THE_STACK_SYMBOL, sax::Token::TokenType::END_ELEMENT);
 }
 
 void SymbolToXMLComposer::compose(std::deque<sax::Token>& out, const EndSymbol&) const {
-	out.push_back(sax::Token(alib::Names::ALPHABET_END_SYMBOL, sax::Token::TokenType::START_ELEMENT));
-	out.push_back(sax::Token(alib::Names::ALPHABET_END_SYMBOL, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::ALPHABET_END_SYMBOL, sax::Token::TokenType::START_ELEMENT);
+	out.emplace_back(alib::Names::ALPHABET_END_SYMBOL, sax::Token::TokenType::END_ELEMENT);
 }
 
 void SymbolToXMLComposer::compose(std::deque<sax::Token>& out, const StartSymbol&) const {
-	out.push_back(sax::Token(alib::Names::ALPHABET_START_SYMBOL, sax::Token::TokenType::START_ELEMENT));
-	out.push_back(sax::Token(alib::Names::ALPHABET_START_SYMBOL, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::ALPHABET_START_SYMBOL, sax::Token::TokenType::START_ELEMENT);
+	out.emplace_back(alib::Names::ALPHABET_START_SYMBOL, sax::Token::TokenType::END_ELEMENT);
 }
 
 void SymbolToXMLComposer::compose(std::deque<sax::Token>& out, const RankedSymbol& symbol) const {
-	out.push_back(sax::Token(alib::Names::ALPHABET_RANKED_SYMBOL, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::ALPHABET_RANKED_SYMBOL, sax::Token::TokenType::START_ELEMENT);
 	alib::xmlApi<label::Label>::compose(out, symbol.getLabel());
 	alib::xmlApi<primitive::Integer>::compose(out, symbol.getRank());
-	out.push_back(sax::Token(alib::Names::ALPHABET_RANKED_SYMBOL, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::ALPHABET_RANKED_SYMBOL, sax::Token::TokenType::END_ELEMENT);
 }
 
 void SymbolToXMLComposer::compose(std::deque<sax::Token>& out, const BarSymbol&) const {
-	out.push_back(sax::Token(alib::Names::ALPHABET_BAR_SYMBOL, sax::Token::TokenType::START_ELEMENT));
-	out.push_back(sax::Token(alib::Names::ALPHABET_BAR_SYMBOL, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::ALPHABET_BAR_SYMBOL, sax::Token::TokenType::START_ELEMENT);
+	out.emplace_back(alib::Names::ALPHABET_BAR_SYMBOL, sax::Token::TokenType::END_ELEMENT);
 }
 
 void SymbolToXMLComposer::compose(std::deque<sax::Token>& out, const RankedBarSymbol& symbol) const {
-	out.push_back(sax::Token(alib::Names::ALPHABET_RANKED_BAR_SYMBOL, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::ALPHABET_RANKED_BAR_SYMBOL, sax::Token::TokenType::START_ELEMENT);
 	alib::xmlApi<primitive::Integer>::compose(out, symbol.getRank());
-	out.push_back(sax::Token(alib::Names::ALPHABET_RANKED_BAR_SYMBOL, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::ALPHABET_RANKED_BAR_SYMBOL, sax::Token::TokenType::END_ELEMENT);
 }
 
 void SymbolToXMLComposer::compose(std::deque<sax::Token>& out, const SubtreeWildcardSymbol&) const {
-	out.push_back(sax::Token(alib::Names::ALPHABET_SUBTREE_WILDCARD_SYMBOL, sax::Token::TokenType::START_ELEMENT));
-	out.push_back(sax::Token(alib::Names::ALPHABET_SUBTREE_WILDCARD_SYMBOL, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::ALPHABET_SUBTREE_WILDCARD_SYMBOL, sax::Token::TokenType::START_ELEMENT);
+	out.emplace_back(alib::Names::ALPHABET_SUBTREE_WILDCARD_SYMBOL, sax::Token::TokenType::END_ELEMENT);
 }
 
 void SymbolToXMLComposer::compose(std::deque<sax::Token>& out, const SymbolSetSymbol& symbol) const {
-	out.push_back(sax::Token(alib::Names::ALPHABET_SYMBOL_SET_SYMBOL, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::ALPHABET_SYMBOL_SET_SYMBOL, sax::Token::TokenType::START_ELEMENT);
 	for(const Symbol& innerSymbol : symbol.getData()) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, innerSymbol);
 	}
-	out.push_back(sax::Token(alib::Names::ALPHABET_SYMBOL_SET_SYMBOL, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::ALPHABET_SYMBOL_SET_SYMBOL, sax::Token::TokenType::END_ELEMENT);
 }
 
 void SymbolToXMLComposer::compose(std::deque<sax::Token>& out, const SymbolPairSymbol& symbol) const {
-	out.push_back(sax::Token(alib::Names::ALPHABET_SYMBOL_PAIR_SYMBOL, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::ALPHABET_SYMBOL_PAIR_SYMBOL, sax::Token::TokenType::START_ELEMENT);
 	alib::xmlApi<alphabet::Symbol>::compose(out, symbol.getData().first);
 	alib::xmlApi<alphabet::Symbol>::compose(out, symbol.getData().second);
-	out.push_back(sax::Token(alib::Names::ALPHABET_SYMBOL_PAIR_SYMBOL, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::ALPHABET_SYMBOL_PAIR_SYMBOL, sax::Token::TokenType::END_ELEMENT);
 }
 
 void SymbolToXMLComposer::compose(std::deque<sax::Token>& out, const UniqueSymbol& symbol) const {
-	out.push_back(sax::Token(alib::Names::ALPHABET_UNIQUE_SYMBOL, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::ALPHABET_UNIQUE_SYMBOL, sax::Token::TokenType::START_ELEMENT);
 	alib::xmlApi<alphabet::Symbol>::compose(out, symbol.getSymbol());
 	alib::xmlApi<primitive::Integer>::compose(out, symbol.getId());
-	out.push_back(sax::Token(alib::Names::ALPHABET_UNIQUE_SYMBOL, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::ALPHABET_UNIQUE_SYMBOL, sax::Token::TokenType::END_ELEMENT);
 }
 
 } /* namespace alphabet */
diff --git a/alib2data/src/automaton/AutomatonToXMLComposer.cpp b/alib2data/src/automaton/AutomatonToXMLComposer.cpp
index 283407882314fd033c10f7ec41642fcdfa74b9b3..737682c9d7930ac6a210793d39cb7e6fa01ba785 100644
--- a/alib2data/src/automaton/AutomatonToXMLComposer.cpp
+++ b/alib2data/src/automaton/AutomatonToXMLComposer.cpp
@@ -13,243 +13,243 @@
 namespace automaton {
 
 void AutomatonToXMLComposer::composeStates(std::deque<sax::Token>& out, const std::set<State>& states) const {
-	out.push_back(sax::Token("states", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("states", sax::Token::TokenType::START_ELEMENT);
 	for (const auto& state : states) {
 		alib::xmlApi<label::Label>::compose(out, state.getName());
 	}
-	out.push_back(sax::Token("states", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("states", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeInputAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const {
-	out.push_back(sax::Token("inputAlphabet", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("inputAlphabet", sax::Token::TokenType::START_ELEMENT);
 	for (const auto& symbol : symbols) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 	}
-	out.push_back(sax::Token("inputAlphabet", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("inputAlphabet", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeCallInputAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const {
-	out.push_back(sax::Token("callInputAlphabet", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("callInputAlphabet", sax::Token::TokenType::START_ELEMENT);
 	for (const auto& symbol : symbols) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 	}
-	out.push_back(sax::Token("callInputAlphabet", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("callInputAlphabet", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeReturnInputAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const {
-	out.push_back(sax::Token("returnInputAlphabet", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("returnInputAlphabet", sax::Token::TokenType::START_ELEMENT);
 	for (const auto& symbol : symbols) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 	}
-	out.push_back(sax::Token("returnInputAlphabet", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("returnInputAlphabet", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeLocalInputAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const {
-	out.push_back(sax::Token("localInputAlphabet", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("localInputAlphabet", sax::Token::TokenType::START_ELEMENT);
 	for (const auto& symbol : symbols) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 	}
-	out.push_back(sax::Token("localInputAlphabet", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("localInputAlphabet", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeInitialStates(std::deque<sax::Token>& out, const std::set<State>& states) const {
-	out.push_back(sax::Token("initialStates", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("initialStates", sax::Token::TokenType::START_ELEMENT);
 	for (const auto& state : states) {
 		alib::xmlApi<label::Label>::compose(out, state.getName());
 	}
-	out.push_back(sax::Token("initialStates", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("initialStates", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeInitialState(std::deque<sax::Token>& out, const State& state) const {
-	out.push_back(sax::Token("initialState", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("initialState", sax::Token::TokenType::START_ELEMENT);
 	alib::xmlApi<label::Label>::compose(out, state.getName());
-	out.push_back(sax::Token("initialState", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("initialState", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeFinalStates(std::deque<sax::Token>& out, const std::set<State>& states) const {
-	out.push_back(sax::Token("finalStates", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("finalStates", sax::Token::TokenType::START_ELEMENT);
 	for (const auto& state : states) {
 		alib::xmlApi<label::Label>::compose(out, state.getName());
 	}
-	out.push_back(sax::Token("finalStates", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("finalStates", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeStackAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const {
-	out.push_back(sax::Token("stackAlphabet", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("stackAlphabet", sax::Token::TokenType::START_ELEMENT);
 	for (const auto& symbol : symbols) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 	}
-	out.push_back(sax::Token("stackAlphabet", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("stackAlphabet", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeInitialStackSymbols(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const {
-	out.push_back(sax::Token("initialStackSymbols", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("initialStackSymbols", sax::Token::TokenType::START_ELEMENT);
 	for (const auto& symbol : symbols) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 	}
-	out.push_back(sax::Token("initialStackSymbols", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("initialStackSymbols", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeInitialStackSymbol(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) const {
-	out.push_back(sax::Token("initialStackSymbol", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("initialStackSymbol", sax::Token::TokenType::START_ELEMENT);
 	alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-	out.push_back(sax::Token("initialStackSymbol", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("initialStackSymbol", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeTapeAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const {
-	out.push_back(sax::Token("tapeAlphabet", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("tapeAlphabet", sax::Token::TokenType::START_ELEMENT);
 	for (const auto& symbol : symbols) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 	}
-	out.push_back(sax::Token("tapeAlphabet", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("tapeAlphabet", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeBlankSymbol(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) const {
-	out.push_back(sax::Token("blankSymbol", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("blankSymbol", sax::Token::TokenType::START_ELEMENT);
 	alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-	out.push_back(sax::Token("blankSymbol", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("blankSymbol", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeBottomOfTheStackSymbol(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) const {
-	out.push_back(sax::Token("bottomOfTheStackSymbol", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("bottomOfTheStackSymbol", sax::Token::TokenType::START_ELEMENT);
 	alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-	out.push_back(sax::Token("bottomOfTheStackSymbol", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("bottomOfTheStackSymbol", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeInputToPushdownStoreOperation(std::deque<sax::Token>& out, const automaton::InputDrivenDPDA& automaton) const {
-	out.push_back(sax::Token("inputToPushdownStoreOperations", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("inputToPushdownStoreOperations", sax::Token::TokenType::START_ELEMENT);
 	for(const auto& pushdownStoreOperation : automaton.getPushdownStoreOperations()) {
-		out.push_back(sax::Token("operation", sax::Token::TokenType::START_ELEMENT));
+		out.emplace_back("operation", sax::Token::TokenType::START_ELEMENT);
 
 		alib::xmlApi<alphabet::Symbol>::compose(out, pushdownStoreOperation.first);
 
 		composeTransitionPop(out, pushdownStoreOperation.second.first);
 		composeTransitionPush(out, pushdownStoreOperation.second.second);
 
-		out.push_back(sax::Token("operation", sax::Token::TokenType::END_ELEMENT));
+		out.emplace_back("operation", sax::Token::TokenType::END_ELEMENT);
 	}
-	out.push_back(sax::Token("inputToPushdownStoreOperations", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("inputToPushdownStoreOperations", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeInputToPushdownStoreOperation(std::deque<sax::Token>& out, const automaton::InputDrivenNPDA& automaton) const {
-	out.push_back(sax::Token("inputToPushdownStoreOperations", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("inputToPushdownStoreOperations", sax::Token::TokenType::START_ELEMENT);
 	for(const auto& pushdownStoreOperation : automaton.getPushdownStoreOperations()) {
-		out.push_back(sax::Token("operation", sax::Token::TokenType::START_ELEMENT));
+		out.emplace_back("operation", sax::Token::TokenType::START_ELEMENT);
 
 		alib::xmlApi<alphabet::Symbol>::compose(out, pushdownStoreOperation.first);
 
 		composeTransitionPop(out, pushdownStoreOperation.second.first);
 		composeTransitionPush(out, pushdownStoreOperation.second.second);
 
-		out.push_back(sax::Token("operation", sax::Token::TokenType::END_ELEMENT));
+		out.emplace_back("operation", sax::Token::TokenType::END_ELEMENT);
 	}
-	out.push_back(sax::Token("inputToPushdownStoreOperations", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("inputToPushdownStoreOperations", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, const DFA& automaton) const {
-	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("transitions", sax::Token::TokenType::START_ELEMENT);
 	for(const auto& transition : automaton.getTransitions()) {
-		out.push_back(sax::Token("transition", sax::Token::TokenType::START_ELEMENT));
+		out.emplace_back("transition", sax::Token::TokenType::START_ELEMENT);
 
 		composeTransitionFrom(out, transition.first.first);
 		composeTransitionInputSymbol(out, transition.first.second);
 		composeTransitionTo(out, transition.second);
 
-		out.push_back(sax::Token("transition", sax::Token::TokenType::END_ELEMENT));
+		out.emplace_back("transition", sax::Token::TokenType::END_ELEMENT);
 	}
 
-	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("transitions", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, const NFA& automaton) const {
-	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("transitions", sax::Token::TokenType::START_ELEMENT);
 	for(const auto& transition : automaton.getTransitions()) {
 		for(const auto& targetState: transition.second) {
-			out.push_back(sax::Token("transition", sax::Token::TokenType::START_ELEMENT));
+			out.emplace_back("transition", sax::Token::TokenType::START_ELEMENT);
 
 			composeTransitionFrom(out, transition.first.first);
 			composeTransitionInputSymbol(out, transition.first.second);
 			composeTransitionTo(out, targetState);
 
-			out.push_back(sax::Token("transition", sax::Token::TokenType::END_ELEMENT));
+			out.emplace_back("transition", sax::Token::TokenType::END_ELEMENT);
 		}
 	}
 
-	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("transitions", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, const MultiInitialStateNFA& automaton) const {
-	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("transitions", sax::Token::TokenType::START_ELEMENT);
 	for(const auto& transition : automaton.getTransitions()) {
 		for(const auto& targetState: transition.second) {
-			out.push_back(sax::Token("transition", sax::Token::TokenType::START_ELEMENT));
+			out.emplace_back("transition", sax::Token::TokenType::START_ELEMENT);
 
 			composeTransitionFrom(out, transition.first.first);
 			composeTransitionInputSymbol(out, transition.first.second);
 			composeTransitionTo(out, targetState);
 
-			out.push_back(sax::Token("transition", sax::Token::TokenType::END_ELEMENT));
+			out.emplace_back("transition", sax::Token::TokenType::END_ELEMENT);
 		}
 	}
 
-	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("transitions", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, const EpsilonNFA& automaton) const {
-	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("transitions", sax::Token::TokenType::START_ELEMENT);
 	for(const auto& transition : automaton.getTransitions()) {
 		for(const auto& targetState: transition.second) {
-			out.push_back(sax::Token("transition", sax::Token::TokenType::START_ELEMENT));
+			out.emplace_back("transition", sax::Token::TokenType::START_ELEMENT);
 
 			composeTransitionFrom(out, transition.first.first);
 			composeTransitionInputEpsilonSymbol(out, transition.first.second);
 			composeTransitionTo(out, targetState);
 
-			out.push_back(sax::Token("transition", sax::Token::TokenType::END_ELEMENT));
+			out.emplace_back("transition", sax::Token::TokenType::END_ELEMENT);
 		}
 	}
 
-	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("transitions", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, const CompactNFA& automaton) const {
-	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("transitions", sax::Token::TokenType::START_ELEMENT);
 	for(const auto& transition : automaton.getTransitions()) {
 		for(const auto& targetState: transition.second) {
-			out.push_back(sax::Token("transition", sax::Token::TokenType::START_ELEMENT));
+			out.emplace_back("transition", sax::Token::TokenType::START_ELEMENT);
 
 			composeTransitionFrom(out, transition.first.first);
 			composeTransitionInputString(out, transition.first.second);
 			composeTransitionTo(out, targetState);
 
-			out.push_back(sax::Token("transition", sax::Token::TokenType::END_ELEMENT));
+			out.emplace_back("transition", sax::Token::TokenType::END_ELEMENT);
 		}
 	}
 
-	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("transitions", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, const ExtendedNFA& automaton) const {
-	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("transitions", sax::Token::TokenType::START_ELEMENT);
 	for(const auto& transition : automaton.getTransitions()) {
 		for(const auto& targetState: transition.second) {
-			out.push_back(sax::Token("transition", sax::Token::TokenType::START_ELEMENT));
+			out.emplace_back("transition", sax::Token::TokenType::START_ELEMENT);
 
 			composeTransitionFrom(out, transition.first.first);
 			composeTransitionInputRegexp(out, transition.first.second);
 			composeTransitionTo(out, targetState);
 
-			out.push_back(sax::Token("transition", sax::Token::TokenType::END_ELEMENT));
+			out.emplace_back("transition", sax::Token::TokenType::END_ELEMENT);
 		}
 	}
 
-	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("transitions", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, const DPDA& automaton) const {
-	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("transitions", sax::Token::TokenType::START_ELEMENT);
 	for(const auto& transition : automaton.getTransitions()) {
-		out.push_back(sax::Token("transition", sax::Token::TokenType::START_ELEMENT));
+		out.emplace_back("transition", sax::Token::TokenType::START_ELEMENT);
 
 		composeTransitionFrom(out, std::get<0>(transition.first));
 		composeTransitionInputEpsilonSymbol(out, std::get<1>(transition.first));
@@ -257,16 +257,16 @@ void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, con
 		composeTransitionTo(out, transition.second.first);
 		composeTransitionPush(out, transition.second.second);
 
-		out.push_back(sax::Token("transition", sax::Token::TokenType::END_ELEMENT));
+		out.emplace_back("transition", sax::Token::TokenType::END_ELEMENT);
 	}
 
-	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("transitions", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, const SinglePopDPDA& automaton) const {
-	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("transitions", sax::Token::TokenType::START_ELEMENT);
 	for(const auto& transition : automaton.getTransitions()) {
-		out.push_back(sax::Token("transition", sax::Token::TokenType::START_ELEMENT));
+		out.emplace_back("transition", sax::Token::TokenType::START_ELEMENT);
 
 		composeTransitionFrom(out, std::get<0>(transition.first));
 		composeTransitionInputEpsilonSymbol(out, std::get<1>(transition.first));
@@ -274,197 +274,197 @@ void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, con
 		composeTransitionTo(out, transition.second.first);
 		composeTransitionPush(out, transition.second.second);
 
-		out.push_back(sax::Token("transition", sax::Token::TokenType::END_ELEMENT));
+		out.emplace_back("transition", sax::Token::TokenType::END_ELEMENT);
 	}
 
-	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("transitions", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, const InputDrivenDPDA& automaton) const {
-	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("transitions", sax::Token::TokenType::START_ELEMENT);
 	for(const auto& transition : automaton.getTransitions()) {
-		out.push_back(sax::Token("transition", sax::Token::TokenType::START_ELEMENT));
+		out.emplace_back("transition", sax::Token::TokenType::START_ELEMENT);
 
 		composeTransitionFrom(out, transition.first.first);
 		composeTransitionInputSymbol(out, transition.first.second);
 		composeTransitionTo(out, transition.second);
 
-		out.push_back(sax::Token("transition", sax::Token::TokenType::END_ELEMENT));
+		out.emplace_back("transition", sax::Token::TokenType::END_ELEMENT);
 	}
 
-	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("transitions", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, const InputDrivenNPDA& automaton) const {
-	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("transitions", sax::Token::TokenType::START_ELEMENT);
 	for(const auto& transition : automaton.getTransitions()) {
 		for(const auto& target: transition.second) {
-			out.push_back(sax::Token("transition", sax::Token::TokenType::START_ELEMENT));
+			out.emplace_back("transition", sax::Token::TokenType::START_ELEMENT);
 
 			composeTransitionFrom(out, transition.first.first);
 			composeTransitionInputSymbol(out, transition.first.second);
 			composeTransitionTo(out, target);
 
-			out.push_back(sax::Token("transition", sax::Token::TokenType::END_ELEMENT));
+			out.emplace_back("transition", sax::Token::TokenType::END_ELEMENT);
 		}
 	}
 
-	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("transitions", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, const VisiblyPushdownDPDA& automaton) const {
-	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("transitions", sax::Token::TokenType::START_ELEMENT);
 	for(const auto& transition : automaton.getCallTransitions()) {
-		out.push_back(sax::Token("callTransition", sax::Token::TokenType::START_ELEMENT));
+		out.emplace_back("callTransition", sax::Token::TokenType::START_ELEMENT);
 
 		composeTransitionFrom(out, transition.first.first);
 		composeTransitionInputSymbol(out, transition.first.second);
 		composeTransitionTo(out, transition.second.first);
 		composeTransitionSinglePush(out, transition.second.second);
 
-		out.push_back(sax::Token("callTransition", sax::Token::TokenType::END_ELEMENT));
+		out.emplace_back("callTransition", sax::Token::TokenType::END_ELEMENT);
 	}
 	for(const auto& transition : automaton.getReturnTransitions()) {
-		out.push_back(sax::Token("returnTransition", sax::Token::TokenType::START_ELEMENT));
+		out.emplace_back("returnTransition", sax::Token::TokenType::START_ELEMENT);
 
 		composeTransitionFrom(out, std::get<0>(transition.first));
 		composeTransitionInputSymbol(out, std::get<1>(transition.first));
 		composeTransitionSinglePop(out, std::get<2>(transition.first));
 		composeTransitionTo(out, transition.second);
 
-		out.push_back(sax::Token("returnTransition", sax::Token::TokenType::END_ELEMENT));
+		out.emplace_back("returnTransition", sax::Token::TokenType::END_ELEMENT);
 	}
 	for(const auto& transition : automaton.getLocalTransitions()) {
-		out.push_back(sax::Token("localTransition", sax::Token::TokenType::START_ELEMENT));
+		out.emplace_back("localTransition", sax::Token::TokenType::START_ELEMENT);
 
 		composeTransitionFrom(out, transition.first.first);
 		composeTransitionInputSymbol(out, transition.first.second);
 		composeTransitionTo(out, transition.second);
 
-		out.push_back(sax::Token("localTransition", sax::Token::TokenType::END_ELEMENT));
+		out.emplace_back("localTransition", sax::Token::TokenType::END_ELEMENT);
 	}
-	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("transitions", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, const VisiblyPushdownNPDA& automaton) const {
-	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("transitions", sax::Token::TokenType::START_ELEMENT);
 	for(const auto& transition : automaton.getCallTransitions()) {
 		for(const auto& target: transition.second) {
-			out.push_back(sax::Token("callTransition", sax::Token::TokenType::START_ELEMENT));
+			out.emplace_back("callTransition", sax::Token::TokenType::START_ELEMENT);
 
 			composeTransitionFrom(out, transition.first.first);
 			composeTransitionInputSymbol(out, transition.first.second);
 			composeTransitionTo(out, target.first);
 			composeTransitionSinglePush(out, target.second);
 
-			out.push_back(sax::Token("callTransition", sax::Token::TokenType::END_ELEMENT));
+			out.emplace_back("callTransition", sax::Token::TokenType::END_ELEMENT);
 		}
 	}
 	for(const auto& transition : automaton.getReturnTransitions()) {
 		for(const auto& target: transition.second) {
-			out.push_back(sax::Token("returnTransition", sax::Token::TokenType::START_ELEMENT));
+			out.emplace_back("returnTransition", sax::Token::TokenType::START_ELEMENT);
 
 			composeTransitionFrom(out, std::get<0>(transition.first));
 			composeTransitionInputSymbol(out, std::get<1>(transition.first));
 			composeTransitionSinglePop(out, std::get<2>(transition.first));
 			composeTransitionTo(out, target);
 
-			out.push_back(sax::Token("returnTransition", sax::Token::TokenType::END_ELEMENT));
+			out.emplace_back("returnTransition", sax::Token::TokenType::END_ELEMENT);
 		}
 	}
 	for(const auto& transition : automaton.getLocalTransitions()) {
 		for(const auto& target: transition.second) {
-			out.push_back(sax::Token("localTransition", sax::Token::TokenType::START_ELEMENT));
+			out.emplace_back("localTransition", sax::Token::TokenType::START_ELEMENT);
 
 			composeTransitionFrom(out, transition.first.first);
 			composeTransitionInputSymbol(out, transition.first.second);
 			composeTransitionTo(out, target);
 
-			out.push_back(sax::Token("localTransition", sax::Token::TokenType::END_ELEMENT));
+			out.emplace_back("localTransition", sax::Token::TokenType::END_ELEMENT);
 		}
 	}
-	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("transitions", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, const RealTimeHeightDeterministicDPDA& automaton) const {
-	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("transitions", sax::Token::TokenType::START_ELEMENT);
 	for(const auto& transition : automaton.getCallTransitions()) {
-		out.push_back(sax::Token("callTransition", sax::Token::TokenType::START_ELEMENT));
+		out.emplace_back("callTransition", sax::Token::TokenType::START_ELEMENT);
 
 		composeTransitionFrom(out, transition.first.first);
 		composeTransitionInputEpsilonSymbol(out, transition.first.second);
 		composeTransitionTo(out, transition.second.first);
 		composeTransitionSinglePush(out, transition.second.second);
 
-		out.push_back(sax::Token("callTransition", sax::Token::TokenType::END_ELEMENT));
+		out.emplace_back("callTransition", sax::Token::TokenType::END_ELEMENT);
 	}
 	for(const auto& transition : automaton.getReturnTransitions()) {
-		out.push_back(sax::Token("returnTransition", sax::Token::TokenType::START_ELEMENT));
+		out.emplace_back("returnTransition", sax::Token::TokenType::START_ELEMENT);
 
 		composeTransitionFrom(out, std::get<0>(transition.first));
 		composeTransitionInputEpsilonSymbol(out, std::get<1>(transition.first));
 		composeTransitionSinglePop(out, std::get<2>(transition.first));
 		composeTransitionTo(out, transition.second);
 
-		out.push_back(sax::Token("returnTransition", sax::Token::TokenType::END_ELEMENT));
+		out.emplace_back("returnTransition", sax::Token::TokenType::END_ELEMENT);
 	}
 	for(const auto& transition : automaton.getLocalTransitions()) {
-		out.push_back(sax::Token("localTransition", sax::Token::TokenType::START_ELEMENT));
+		out.emplace_back("localTransition", sax::Token::TokenType::START_ELEMENT);
 
 		composeTransitionFrom(out, transition.first.first);
 		composeTransitionInputEpsilonSymbol(out, transition.first.second);
 		composeTransitionTo(out, transition.second);
 
-		out.push_back(sax::Token("localTransition", sax::Token::TokenType::END_ELEMENT));
+		out.emplace_back("localTransition", sax::Token::TokenType::END_ELEMENT);
 	}
-	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("transitions", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, const RealTimeHeightDeterministicNPDA& automaton) const {
-	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("transitions", sax::Token::TokenType::START_ELEMENT);
 	for(const auto& transition : automaton.getCallTransitions()) {
 		for(const auto& target: transition.second) {
-			out.push_back(sax::Token("callTransition", sax::Token::TokenType::START_ELEMENT));
+			out.emplace_back("callTransition", sax::Token::TokenType::START_ELEMENT);
 
 			composeTransitionFrom(out, transition.first.first);
 			composeTransitionInputEpsilonSymbol(out, transition.first.second);
 			composeTransitionTo(out, target.first);
 			composeTransitionSinglePush(out, target.second);
 
-			out.push_back(sax::Token("callTransition", sax::Token::TokenType::END_ELEMENT));
+			out.emplace_back("callTransition", sax::Token::TokenType::END_ELEMENT);
 		}
 	}
 	for(const auto& transition : automaton.getReturnTransitions()) {
 		for(const auto& target: transition.second) {
-			out.push_back(sax::Token("returnTransition", sax::Token::TokenType::START_ELEMENT));
+			out.emplace_back("returnTransition", sax::Token::TokenType::START_ELEMENT);
 
 			composeTransitionFrom(out, std::get<0>(transition.first));
 			composeTransitionInputEpsilonSymbol(out, std::get<1>(transition.first));
 			composeTransitionSinglePop(out, std::get<2>(transition.first));
 			composeTransitionTo(out, target);
 
-			out.push_back(sax::Token("returnTransition", sax::Token::TokenType::END_ELEMENT));
+			out.emplace_back("returnTransition", sax::Token::TokenType::END_ELEMENT);
 		}
 	}
 	for(const auto& transition : automaton.getLocalTransitions()) {
 		for(const auto& target: transition.second) {
-			out.push_back(sax::Token("localTransition", sax::Token::TokenType::START_ELEMENT));
+			out.emplace_back("localTransition", sax::Token::TokenType::START_ELEMENT);
 
 			composeTransitionFrom(out, transition.first.first);
 			composeTransitionInputEpsilonSymbol(out, transition.first.second);
 			composeTransitionTo(out, target);
 
-			out.push_back(sax::Token("localTransition", sax::Token::TokenType::END_ELEMENT));
+			out.emplace_back("localTransition", sax::Token::TokenType::END_ELEMENT);
 		}
 	}
-	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("transitions", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, const NPDA& automaton) const {
-	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("transitions", sax::Token::TokenType::START_ELEMENT);
 	for(const auto& transition : automaton.getTransitions()) {
 		for(const auto& target: transition.second) {
-			out.push_back(sax::Token("transition", sax::Token::TokenType::START_ELEMENT));
+			out.emplace_back("transition", sax::Token::TokenType::START_ELEMENT);
 
 			composeTransitionFrom(out, std::get<0>(transition.first));
 			composeTransitionInputEpsilonSymbol(out, std::get<1>(transition.first));
@@ -472,18 +472,18 @@ void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, con
 			composeTransitionTo(out, target.first);
 			composeTransitionPush(out, target.second);
 
-			out.push_back(sax::Token("transition", sax::Token::TokenType::END_ELEMENT));
+			out.emplace_back("transition", sax::Token::TokenType::END_ELEMENT);
 		}
 	}
 
-	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("transitions", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, const SinglePopNPDA& automaton) const {
-	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("transitions", sax::Token::TokenType::START_ELEMENT);
 	for(const auto& transition : automaton.getTransitions()) {
 		for(const auto& target: transition.second) {
-			out.push_back(sax::Token("transition", sax::Token::TokenType::START_ELEMENT));
+			out.emplace_back("transition", sax::Token::TokenType::START_ELEMENT);
 
 			composeTransitionFrom(out, std::get<0>(transition.first));
 			composeTransitionInputEpsilonSymbol(out, std::get<1>(transition.first));
@@ -491,17 +491,17 @@ void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, con
 			composeTransitionTo(out, target.first);
 			composeTransitionPush(out, target.second);
 
-			out.push_back(sax::Token("transition", sax::Token::TokenType::END_ELEMENT));
+			out.emplace_back("transition", sax::Token::TokenType::END_ELEMENT);
 		}
 	}
 
-	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("transitions", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, const OneTapeDTM& automaton) const {
-	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("transitions", sax::Token::TokenType::START_ELEMENT);
 	for(const auto& transition : automaton.getTransitions()) {
-		out.push_back(sax::Token("transition", sax::Token::TokenType::START_ELEMENT));
+		out.emplace_back("transition", sax::Token::TokenType::START_ELEMENT);
 
 		composeTransitionFrom(out, transition.first.first);
 		composeTransitionInputSymbol(out, transition.first.second);
@@ -509,102 +509,102 @@ void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, con
 		composeTransitionOutputSymbol(out, std::get<1>(transition.second));
 		composeTransitionShift(out, std::get<2>(transition.second));
 
-		out.push_back(sax::Token("transition", sax::Token::TokenType::END_ELEMENT));
+		out.emplace_back("transition", sax::Token::TokenType::END_ELEMENT);
 	}
 
-	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("transitions", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeTransitionTo(std::deque<sax::Token>& out, const State& state) const {
-	out.push_back(sax::Token("to", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("to", sax::Token::TokenType::START_ELEMENT);
 	alib::xmlApi<label::Label>::compose(out, state.getName());
-	out.push_back(sax::Token("to", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("to", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeTransitionFrom(std::deque<sax::Token>& out, const State& state) const {
-	out.push_back(sax::Token("from", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("from", sax::Token::TokenType::START_ELEMENT);
 	alib::xmlApi<label::Label>::compose(out, state.getName());
-	out.push_back(sax::Token("from", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("from", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeTransitionShift(std::deque<sax::Token>& out, const Shift shift) const {
-	out.push_back(sax::Token("shift", sax::Token::TokenType::START_ELEMENT));
-	out.push_back(sax::Token(SHIFT_NAMES [shift], sax::Token::TokenType::CHARACTER));
-	out.push_back(sax::Token("shift", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("shift", sax::Token::TokenType::START_ELEMENT);
+	out.emplace_back(SHIFT_NAMES [shift], sax::Token::TokenType::CHARACTER);
+	out.emplace_back("shift", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeTransitionPop(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) const {
-	out.push_back(sax::Token("pop", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("pop", sax::Token::TokenType::START_ELEMENT);
 	for (const auto& symbol : symbols) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 	}
-	out.push_back(sax::Token("pop", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("pop", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeTransitionSinglePop(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) const {
-	out.push_back(sax::Token("pop", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("pop", sax::Token::TokenType::START_ELEMENT);
 	alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-	out.push_back(sax::Token("pop", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("pop", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeTransitionPush(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) const {
-	out.push_back(sax::Token("push", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("push", sax::Token::TokenType::START_ELEMENT);
 	for (const auto& symbol : symbols) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 	}
-	out.push_back(sax::Token("push", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("push", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeTransitionSinglePush(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) const {
-	out.push_back(sax::Token("push", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("push", sax::Token::TokenType::START_ELEMENT);
 	alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-	out.push_back(sax::Token("push", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("push", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeTransitionInputSymbol(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) const {
-	out.push_back(sax::Token("input", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("input", sax::Token::TokenType::START_ELEMENT);
 	alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-	out.push_back(sax::Token("input", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("input", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeTransitionOutputSymbol(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) const {
-	out.push_back(sax::Token("output", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("output", sax::Token::TokenType::START_ELEMENT);
 	alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-	out.push_back(sax::Token("output", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("output", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeTransitionInputEpsilonSymbol(std::deque<sax::Token>& out, const std::variant<string::Epsilon, alphabet::Symbol>& symbol) const {
-	out.push_back(sax::Token("input", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("input", sax::Token::TokenType::START_ELEMENT);
 	if(symbol.is<string::Epsilon>()) {
-		out.push_back(sax::Token("epsilon", sax::Token::TokenType::START_ELEMENT));
-		out.push_back(sax::Token("epsilon", sax::Token::TokenType::END_ELEMENT));
+		out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
+		out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
 	} else {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbol.get<alphabet::Symbol>());
 	}
-	out.push_back(sax::Token("input", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("input", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeTransitionOutputEpsilonSymbol(std::deque<sax::Token>& out, const std::variant<string::Epsilon, alphabet::Symbol>& symbol) const {
-	out.push_back(sax::Token("output", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("output", sax::Token::TokenType::START_ELEMENT);
 	if(symbol.is<string::Epsilon>()) {
-		out.push_back(sax::Token("epsilon", sax::Token::TokenType::START_ELEMENT));
-		out.push_back(sax::Token("epsilon", sax::Token::TokenType::END_ELEMENT));
+		out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
+		out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
 	} else {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbol.get<alphabet::Symbol>());
 	}
-	out.push_back(sax::Token("output", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("output", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeTransitionInputString(std::deque<sax::Token>& out, const string::LinearString& string) const {
-	out.push_back(sax::Token("input", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("input", sax::Token::TokenType::START_ELEMENT);
 	alib::xmlApi<string::LinearString>::compose(out, string);
-	out.push_back(sax::Token("input", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("input", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::composeTransitionInputRegexp(std::deque<sax::Token>& out, const regexp::RegExp& regexp) const {
-	out.push_back(sax::Token("input", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("input", sax::Token::TokenType::START_ELEMENT);
 	alib::xmlApi<regexp::RegExp>::compose(out, regexp);
-	out.push_back(sax::Token("input", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("input", sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const Automaton& automaton) const {
@@ -616,7 +616,7 @@ void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const Automato
 }
 
 void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const DFA& automaton) const {
-	out.push_back(sax::Token(alib::Names::AUTOMATON_DFA, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::AUTOMATON_DFA, sax::Token::TokenType::START_ELEMENT);
 
 	composeStates(out, automaton.getStates());
 	composeInputAlphabet(out, automaton.getInputAlphabet());
@@ -624,11 +624,11 @@ void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const DFA& aut
 	composeFinalStates(out, automaton.getFinalStates());
 	composeTransitions(out, automaton);
 
-	out.push_back(sax::Token(alib::Names::AUTOMATON_DFA, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::AUTOMATON_DFA, sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const NFA& automaton) const {
-	out.push_back(sax::Token(alib::Names::AUTOMATON_NFA, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::AUTOMATON_NFA, sax::Token::TokenType::START_ELEMENT);
 
 	composeStates(out, automaton.getStates());
 	composeInputAlphabet(out, automaton.getInputAlphabet());
@@ -636,11 +636,11 @@ void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const NFA& aut
 	composeFinalStates(out, automaton.getFinalStates());
 	composeTransitions(out, automaton);
 
-	out.push_back(sax::Token(alib::Names::AUTOMATON_NFA, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::AUTOMATON_NFA, sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const MultiInitialStateNFA& automaton) const {
-	out.push_back(sax::Token(alib::Names::AUTOMATON_MULTI_INITIAL_STATE_NFA, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::AUTOMATON_MULTI_INITIAL_STATE_NFA, sax::Token::TokenType::START_ELEMENT);
 
 	composeStates(out, automaton.getStates());
 	composeInputAlphabet(out, automaton.getInputAlphabet());
@@ -648,11 +648,11 @@ void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const MultiIni
 	composeFinalStates(out, automaton.getFinalStates());
 	composeTransitions(out, automaton);
 
-	out.push_back(sax::Token(alib::Names::AUTOMATON_MULTI_INITIAL_STATE_NFA, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::AUTOMATON_MULTI_INITIAL_STATE_NFA, sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const EpsilonNFA& automaton) const {
-	out.push_back(sax::Token(alib::Names::AUTOMATON_EPSILON_NFA, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::AUTOMATON_EPSILON_NFA, sax::Token::TokenType::START_ELEMENT);
 
 	composeStates(out, automaton.getStates());
 	composeInputAlphabet(out, automaton.getInputAlphabet());
@@ -660,11 +660,11 @@ void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const EpsilonN
 	composeFinalStates(out, automaton.getFinalStates());
 	composeTransitions(out, automaton);
 
-	out.push_back(sax::Token(alib::Names::AUTOMATON_EPSILON_NFA, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::AUTOMATON_EPSILON_NFA, sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const ExtendedNFA& automaton) const {
-	out.push_back(sax::Token(alib::Names::AUTOMATON_EXTENDED_NFA, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::AUTOMATON_EXTENDED_NFA, sax::Token::TokenType::START_ELEMENT);
 
 	composeStates(out, automaton.getStates());
 	composeInputAlphabet(out, automaton.getInputAlphabet());
@@ -672,11 +672,11 @@ void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const Extended
 	composeFinalStates(out, automaton.getFinalStates());
 	composeTransitions(out, automaton);
 
-	out.push_back(sax::Token(alib::Names::AUTOMATON_EXTENDED_NFA, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::AUTOMATON_EXTENDED_NFA, sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const CompactNFA& automaton) const {
-	out.push_back(sax::Token(alib::Names::AUTOMATON_COMPACT_NFA, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::AUTOMATON_COMPACT_NFA, sax::Token::TokenType::START_ELEMENT);
 
 	composeStates(out, automaton.getStates());
 	composeInputAlphabet(out, automaton.getInputAlphabet());
@@ -684,11 +684,11 @@ void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const CompactN
 	composeFinalStates(out, automaton.getFinalStates());
 	composeTransitions(out, automaton);
 
-	out.push_back(sax::Token(alib::Names::AUTOMATON_COMPACT_NFA, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::AUTOMATON_COMPACT_NFA, sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const DPDA& automaton) const {
-	out.push_back(sax::Token(alib::Names::AUTOMATON_DPDA, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::AUTOMATON_DPDA, sax::Token::TokenType::START_ELEMENT);
 
 	composeStates(out, automaton.getStates());
 	composeInputAlphabet(out, automaton.getInputAlphabet());
@@ -698,11 +698,11 @@ void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const DPDA& au
 	composeFinalStates(out, automaton.getFinalStates());
 	composeTransitions(out, automaton);
 
-	out.push_back(sax::Token(alib::Names::AUTOMATON_DPDA, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::AUTOMATON_DPDA, sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const SinglePopDPDA& automaton) const {
-	out.push_back(sax::Token(alib::Names::AUTOMATON_SINGLE_POP_DPDA, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::AUTOMATON_SINGLE_POP_DPDA, sax::Token::TokenType::START_ELEMENT);
 
 	composeStates(out, automaton.getStates());
 	composeInputAlphabet(out, automaton.getInputAlphabet());
@@ -712,11 +712,11 @@ void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const SinglePo
 	composeFinalStates(out, automaton.getFinalStates());
 	composeTransitions(out, automaton);
 
-	out.push_back(sax::Token(alib::Names::AUTOMATON_SINGLE_POP_DPDA, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::AUTOMATON_SINGLE_POP_DPDA, sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const InputDrivenDPDA& automaton) const {
-	out.push_back(sax::Token(alib::Names::AUTOMATON_INPUT_DRIVEN_DPDA, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::AUTOMATON_INPUT_DRIVEN_DPDA, sax::Token::TokenType::START_ELEMENT);
 
 	composeStates(out, automaton.getStates());
 	composeInputAlphabet(out, automaton.getInputAlphabet());
@@ -727,11 +727,11 @@ void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const InputDri
 	composeInputToPushdownStoreOperation(out, automaton);
 	composeTransitions(out, automaton);
 
-	out.push_back(sax::Token(alib::Names::AUTOMATON_INPUT_DRIVEN_DPDA, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::AUTOMATON_INPUT_DRIVEN_DPDA, sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const InputDrivenNPDA& automaton) const {
-	out.push_back(sax::Token(alib::Names::AUTOMATON_INPUT_DRIVEN_NPDA, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::AUTOMATON_INPUT_DRIVEN_NPDA, sax::Token::TokenType::START_ELEMENT);
 
 	composeStates(out, automaton.getStates());
 	composeInputAlphabet(out, automaton.getInputAlphabet());
@@ -742,11 +742,11 @@ void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const InputDri
 	composeInputToPushdownStoreOperation(out, automaton);
 	composeTransitions(out, automaton);
 
-	out.push_back(sax::Token(alib::Names::AUTOMATON_INPUT_DRIVEN_NPDA, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::AUTOMATON_INPUT_DRIVEN_NPDA, sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const VisiblyPushdownDPDA& automaton) const {
-	out.push_back(sax::Token(alib::Names::AUTOMATON_VISIBLY_PUSHDOWN_DPDA, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::AUTOMATON_VISIBLY_PUSHDOWN_DPDA, sax::Token::TokenType::START_ELEMENT);
 
 	composeStates(out, automaton.getStates());
 	composeCallInputAlphabet(out, automaton.getCallInputAlphabet());
@@ -758,11 +758,11 @@ void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const VisiblyP
 	composeFinalStates(out, automaton.getFinalStates());
 	composeTransitions(out, automaton);
 
-	out.push_back(sax::Token(alib::Names::AUTOMATON_VISIBLY_PUSHDOWN_DPDA, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::AUTOMATON_VISIBLY_PUSHDOWN_DPDA, sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const VisiblyPushdownNPDA& automaton) const {
-	out.push_back(sax::Token(alib::Names::AUTOMATON_VISIBLY_PUSHDOWN_NPDA, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::AUTOMATON_VISIBLY_PUSHDOWN_NPDA, sax::Token::TokenType::START_ELEMENT);
 
 	composeStates(out, automaton.getStates());
 	composeCallInputAlphabet(out, automaton.getCallInputAlphabet());
@@ -774,11 +774,11 @@ void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const VisiblyP
 	composeFinalStates(out, automaton.getFinalStates());
 	composeTransitions(out, automaton);
 
-	out.push_back(sax::Token(alib::Names::AUTOMATON_VISIBLY_PUSHDOWN_NPDA, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::AUTOMATON_VISIBLY_PUSHDOWN_NPDA, sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const RealTimeHeightDeterministicDPDA& automaton) const {
-	out.push_back(sax::Token(alib::Names::AUTOMATON_REAL_TIME_HEIGHT_DETERMINISTIC_DPDA, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::AUTOMATON_REAL_TIME_HEIGHT_DETERMINISTIC_DPDA, sax::Token::TokenType::START_ELEMENT);
 
 	composeStates(out, automaton.getStates());
 	composeInputAlphabet(out, automaton.getInputAlphabet());
@@ -788,11 +788,11 @@ void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const RealTime
 	composeFinalStates(out, automaton.getFinalStates());
 	composeTransitions(out, automaton);
 
-	out.push_back(sax::Token(alib::Names::AUTOMATON_REAL_TIME_HEIGHT_DETERMINISTIC_DPDA, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::AUTOMATON_REAL_TIME_HEIGHT_DETERMINISTIC_DPDA, sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const RealTimeHeightDeterministicNPDA& automaton) const {
-	out.push_back(sax::Token(alib::Names::AUTOMATON_REAL_TIME_HEIGHT_DETERMINISTIC_NPDA, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::AUTOMATON_REAL_TIME_HEIGHT_DETERMINISTIC_NPDA, sax::Token::TokenType::START_ELEMENT);
 
 	composeStates(out, automaton.getStates());
 	composeInputAlphabet(out, automaton.getInputAlphabet());
@@ -802,11 +802,11 @@ void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const RealTime
 	composeFinalStates(out, automaton.getFinalStates());
 	composeTransitions(out, automaton);
 
-	out.push_back(sax::Token(alib::Names::AUTOMATON_REAL_TIME_HEIGHT_DETERMINISTIC_NPDA, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::AUTOMATON_REAL_TIME_HEIGHT_DETERMINISTIC_NPDA, sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const NPDA& automaton) const {
-	out.push_back(sax::Token(alib::Names::AUTOMATON_NPDA, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::AUTOMATON_NPDA, sax::Token::TokenType::START_ELEMENT);
 
 	composeStates(out, automaton.getStates());
 	composeInputAlphabet(out, automaton.getInputAlphabet());
@@ -816,11 +816,11 @@ void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const NPDA& au
 	composeFinalStates(out, automaton.getFinalStates());
 	composeTransitions(out, automaton);
 
-	out.push_back(sax::Token(alib::Names::AUTOMATON_NPDA, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::AUTOMATON_NPDA, sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const SinglePopNPDA& automaton) const {
-	out.push_back(sax::Token(alib::Names::AUTOMATON_SINGLE_POP_NPDA, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::AUTOMATON_SINGLE_POP_NPDA, sax::Token::TokenType::START_ELEMENT);
 
 	composeStates(out, automaton.getStates());
 	composeInputAlphabet(out, automaton.getInputAlphabet());
@@ -830,11 +830,11 @@ void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const SinglePo
 	composeFinalStates(out, automaton.getFinalStates());
 	composeTransitions(out, automaton);
 
-	out.push_back(sax::Token(alib::Names::AUTOMATON_SINGLE_POP_NPDA, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::AUTOMATON_SINGLE_POP_NPDA, sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const OneTapeDTM& automaton) const {
-	out.push_back(sax::Token(alib::Names::AUTOMATON_ONE_TAPE_DTM, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::AUTOMATON_ONE_TAPE_DTM, sax::Token::TokenType::START_ELEMENT);
 
 	composeStates(out, automaton.getStates());
 	composeTapeAlphabet(out, automaton.getTapeAlphabet());
@@ -844,7 +844,7 @@ void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const OneTapeD
 	composeFinalStates(out, automaton.getFinalStates());
 	composeTransitions(out, automaton);
 
-	out.push_back(sax::Token(alib::Names::AUTOMATON_ONE_TAPE_DTM, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::AUTOMATON_ONE_TAPE_DTM, sax::Token::TokenType::END_ELEMENT);
 }
 
 void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const State& state) const {
diff --git a/alib2data/src/container/ContainerToXMLComposer.cpp b/alib2data/src/container/ContainerToXMLComposer.cpp
index 32220914e4cad944970eb7f00f60d38196221ebf..a2dd30ea3fdfc3a2eb274e49f2265ed1760e2700 100644
--- a/alib2data/src/container/ContainerToXMLComposer.cpp
+++ b/alib2data/src/container/ContainerToXMLComposer.cpp
@@ -18,42 +18,42 @@ void ContainerToXMLComposer::compose(std::deque<sax::Token>& out, const Containe
 }
 
 void ContainerToXMLComposer::compose(std::deque<sax::Token>& out, const ObjectsSet& container) const {
-	out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_SET, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::CONTAINER_OBJECTS_SET, sax::Token::TokenType::START_ELEMENT);
 
 	for(const alib::Object& item : container) {
 		alib::xmlApi<alib::Object>::compose(out, item);
 	}
 
-	out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_SET, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::CONTAINER_OBJECTS_SET, sax::Token::TokenType::END_ELEMENT);
 }
 
 void ContainerToXMLComposer::compose(std::deque<sax::Token>& out, const ObjectsVector& container) const {
-	out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_VECTOR, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::CONTAINER_OBJECTS_VECTOR, sax::Token::TokenType::START_ELEMENT);
 
 	for(const alib::Object& item : container) {
 		alib::xmlApi<alib::Object>::compose(out, item);
 	}
 
-	out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_VECTOR, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::CONTAINER_OBJECTS_VECTOR, sax::Token::TokenType::END_ELEMENT);
 }
 
 void ContainerToXMLComposer::compose(std::deque<sax::Token>& out, const ObjectsPair& container) const {
-	out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_PAIR, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::CONTAINER_OBJECTS_PAIR, sax::Token::TokenType::START_ELEMENT);
 
 	alib::xmlApi<alib::Object>::compose(out, container.first);
 	alib::xmlApi<alib::Object>::compose(out, container.second);
 
-	out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_PAIR, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::CONTAINER_OBJECTS_PAIR, sax::Token::TokenType::END_ELEMENT);
 }
 
 void ContainerToXMLComposer::compose(std::deque<sax::Token>& out, const ObjectsMap& container) const {
-	out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_MAP, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::CONTAINER_OBJECTS_MAP, sax::Token::TokenType::START_ELEMENT);
 
 	for(const std::pair<alib::Object, alib::Object>& item : container) {
 		alib::xmlApi<std::pair<alib::Object, alib::Object>>::compose(out, item);
 	}
 
-	out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_MAP, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::CONTAINER_OBJECTS_MAP, sax::Token::TokenType::END_ELEMENT);
 }
 
 } /* namespace container */
diff --git a/alib2data/src/container/ContainerToXMLComposer.hpp b/alib2data/src/container/ContainerToXMLComposer.hpp
index 86dcc3af5fe18ea257658904703e0b69cfb19991..fd4d685995b37bb7b6c6f0748271534d24d2bf6a 100644
--- a/alib2data/src/container/ContainerToXMLComposer.hpp
+++ b/alib2data/src/container/ContainerToXMLComposer.hpp
@@ -78,45 +78,45 @@ namespace container {
 
 template<typename T>
 void ContainerToXMLComposer::compose(std::deque<sax::Token>& out, const std::set<T>& container) const {
-	out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_SET, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::CONTAINER_OBJECTS_SET, sax::Token::TokenType::START_ELEMENT);
 
 	for(const T& item : container) {
 		alib::xmlApi<T>::compose(out, item);
 	}
 
-	out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_SET, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::CONTAINER_OBJECTS_SET, sax::Token::TokenType::END_ELEMENT);
 }
 
 template<typename T>
 void ContainerToXMLComposer::compose(std::deque<sax::Token>& out, const std::vector<T>& container) const {
-	out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_VECTOR, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::CONTAINER_OBJECTS_VECTOR, sax::Token::TokenType::START_ELEMENT);
 
 	for(const T& item : container) {
 		alib::xmlApi<T>::compose(out, item);
 	}
 
-	out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_VECTOR, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::CONTAINER_OBJECTS_VECTOR, sax::Token::TokenType::END_ELEMENT);
 }
 
 template<typename T, typename R>
 void ContainerToXMLComposer::compose(std::deque<sax::Token>& out, const std::pair<T, R>& container) const {
-	out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_PAIR, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::CONTAINER_OBJECTS_PAIR, sax::Token::TokenType::START_ELEMENT);
 
 	alib::xmlApi<T>::compose(out, container.first);
 	alib::xmlApi<R>::compose(out, container.second);
 
-	out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_PAIR, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::CONTAINER_OBJECTS_PAIR, sax::Token::TokenType::END_ELEMENT);
 }
 
 template<typename T, typename R>
 void ContainerToXMLComposer::compose(std::deque<sax::Token>& out, const std::map<T, R>& container) const {
-	out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_MAP, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::CONTAINER_OBJECTS_MAP, sax::Token::TokenType::START_ELEMENT);
 
 	for(const std::pair<T, R>& item : container) {
 		alib::xmlApi<std::pair<T, R>>::compose(out, item);
 	}
 
-	out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_MAP, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::CONTAINER_OBJECTS_MAP, sax::Token::TokenType::END_ELEMENT);
 }
 
 /* TODO for gcc-4.9 uncomment
diff --git a/alib2data/src/exception/ExceptionToXMLComposer.cpp b/alib2data/src/exception/ExceptionToXMLComposer.cpp
index 90c9d7d76506f148f03727c336f77ae5b4e63e4d..32482eb4bfb18ec9d8c20840e6ae6a271061ae60 100644
--- a/alib2data/src/exception/ExceptionToXMLComposer.cpp
+++ b/alib2data/src/exception/ExceptionToXMLComposer.cpp
@@ -12,14 +12,14 @@
 namespace exception {
 
 void ExceptionToXMLComposer::compose(std::deque<sax::Token>& out, const AlibException& exception) const {
-	out.push_back(sax::Token(alib::Names::EXCEPTION_ALIB_EXCEPTION, sax::Token::TokenType::START_ELEMENT));
-	out.push_back(sax::Token("cause", sax::Token::TokenType::START_ELEMENT));
-	out.push_back(sax::Token(exception.getCause(), sax::Token::TokenType::CHARACTER));
-	out.push_back(sax::Token("cause", sax::Token::TokenType::END_ELEMENT));
-	out.push_back(sax::Token("backtrace", sax::Token::TokenType::START_ELEMENT));
-	out.push_back(sax::Token(exception.getBacktrace(), sax::Token::TokenType::CHARACTER));
-	out.push_back(sax::Token("backtrace", sax::Token::TokenType::END_ELEMENT));
-	out.push_back(sax::Token(alib::Names::EXCEPTION_ALIB_EXCEPTION, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::EXCEPTION_ALIB_EXCEPTION, sax::Token::TokenType::START_ELEMENT);
+	out.emplace_back("cause", sax::Token::TokenType::START_ELEMENT);
+	out.emplace_back(exception.getCause(), sax::Token::TokenType::CHARACTER);
+	out.emplace_back("cause", sax::Token::TokenType::END_ELEMENT);
+	out.emplace_back("backtrace", sax::Token::TokenType::START_ELEMENT);
+	out.emplace_back(exception.getBacktrace(), sax::Token::TokenType::CHARACTER);
+	out.emplace_back("backtrace", sax::Token::TokenType::END_ELEMENT);
+	out.emplace_back(alib::Names::EXCEPTION_ALIB_EXCEPTION, sax::Token::TokenType::END_ELEMENT);
 }
 
 } /* namespace exception */
diff --git a/alib2data/src/grammar/GrammarToXMLComposer.cpp b/alib2data/src/grammar/GrammarToXMLComposer.cpp
index 8fa4f35f27859c793eb542bd288ae7292a1de139..0cde5b137d7b523ea8342f56bc7fcb03fb9efced 100644
--- a/alib2data/src/grammar/GrammarToXMLComposer.cpp
+++ b/alib2data/src/grammar/GrammarToXMLComposer.cpp
@@ -21,18 +21,18 @@ void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const Grammar& g
 }
 
 void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const LeftLG& grammar) const {
-	out.push_back(sax::Token(alib::Names::GRAMMAR_LEFT_LG, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::GRAMMAR_LEFT_LG, sax::Token::TokenType::START_ELEMENT);
 
 	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
 	composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
 	composeInitialSymbol(out, grammar.getInitialSymbol());
 	composeRules(out, grammar);
 
-	out.push_back(sax::Token(alib::Names::GRAMMAR_LEFT_LG, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::GRAMMAR_LEFT_LG, sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const LeftRG& grammar) const {
-	out.push_back(sax::Token(alib::Names::GRAMMAR_LEFT_RG, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::GRAMMAR_LEFT_RG, sax::Token::TokenType::START_ELEMENT);
 
 	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
 	composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
@@ -40,22 +40,22 @@ void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const LeftRG& gr
 	composeRules(out, grammar);
 	composeGeneratesEpsilon(out, grammar.getGeneratesEpsilon());
 
-	out.push_back(sax::Token(alib::Names::GRAMMAR_LEFT_RG, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::GRAMMAR_LEFT_RG, sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const RightLG& grammar) const {
-	out.push_back(sax::Token(alib::Names::GRAMMAR_RIGHT_LG, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::GRAMMAR_RIGHT_LG, sax::Token::TokenType::START_ELEMENT);
 
 	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
 	composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
 	composeInitialSymbol(out, grammar.getInitialSymbol());
 	composeRules(out, grammar);
 
-	out.push_back(sax::Token(alib::Names::GRAMMAR_RIGHT_LG, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::GRAMMAR_RIGHT_LG, sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const RightRG& grammar) const {
-	out.push_back(sax::Token(alib::Names::GRAMMAR_RIGHT_RG, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::GRAMMAR_RIGHT_RG, sax::Token::TokenType::START_ELEMENT);
 
 	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
 	composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
@@ -63,33 +63,33 @@ void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const RightRG& g
 	composeRules(out, grammar);
 	composeGeneratesEpsilon(out, grammar.getGeneratesEpsilon());
 
-	out.push_back(sax::Token(alib::Names::GRAMMAR_RIGHT_RG, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::GRAMMAR_RIGHT_RG, sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const LG& grammar) const {
-	out.push_back(sax::Token(alib::Names::GRAMMAR_LG, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::GRAMMAR_LG, sax::Token::TokenType::START_ELEMENT);
 
 	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
 	composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
 	composeInitialSymbol(out, grammar.getInitialSymbol());
 	composeRules(out, grammar);
 
-	out.push_back(sax::Token(alib::Names::GRAMMAR_LG, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::GRAMMAR_LG, sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const CFG& grammar) const {
-	out.push_back(sax::Token(alib::Names::GRAMMAR_CFG, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::GRAMMAR_CFG, sax::Token::TokenType::START_ELEMENT);
 
 	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
 	composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
 	composeInitialSymbol(out, grammar.getInitialSymbol());
 	composeRules(out, grammar);
 
-	out.push_back(sax::Token(alib::Names::GRAMMAR_CFG, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::GRAMMAR_CFG, sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const EpsilonFreeCFG& grammar) const {
-	out.push_back(sax::Token(alib::Names::GRAMMAR_EPSILON_FREE_CFG, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::GRAMMAR_EPSILON_FREE_CFG, sax::Token::TokenType::START_ELEMENT);
 
 	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
 	composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
@@ -97,11 +97,11 @@ void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const EpsilonFre
 	composeRules(out, grammar);
 	composeGeneratesEpsilon(out, grammar.getGeneratesEpsilon());
 
-	out.push_back(sax::Token(alib::Names::GRAMMAR_EPSILON_FREE_CFG, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::GRAMMAR_EPSILON_FREE_CFG, sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const CNF& grammar) const {
-	out.push_back(sax::Token(alib::Names::GRAMMAR_CNF, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::GRAMMAR_CNF, sax::Token::TokenType::START_ELEMENT);
 
 	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
 	composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
@@ -109,11 +109,11 @@ void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const CNF& gramm
 	composeRules(out, grammar);
 	composeGeneratesEpsilon(out, grammar.getGeneratesEpsilon());
 
-	out.push_back(sax::Token(alib::Names::GRAMMAR_CNF, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::GRAMMAR_CNF, sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const GNF& grammar) const {
-	out.push_back(sax::Token(alib::Names::GRAMMAR_GNF, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::GRAMMAR_GNF, sax::Token::TokenType::START_ELEMENT);
 
 	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
 	composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
@@ -121,11 +121,11 @@ void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const GNF& gramm
 	composeRules(out, grammar);
 	composeGeneratesEpsilon(out, grammar.getGeneratesEpsilon());
 
-	out.push_back(sax::Token(alib::Names::GRAMMAR_GNF, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::GRAMMAR_GNF, sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const CSG& grammar) const {
-	out.push_back(sax::Token(alib::Names::GRAMMAR_CSG, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::GRAMMAR_CSG, sax::Token::TokenType::START_ELEMENT);
 
 	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
 	composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
@@ -133,11 +133,11 @@ void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const CSG& gramm
 	composeRules(out, grammar);
 	composeGeneratesEpsilon(out, grammar.getGeneratesEpsilon());
 
-	out.push_back(sax::Token(alib::Names::GRAMMAR_CSG, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::GRAMMAR_CSG, sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const NonContractingGrammar& grammar) const {
-	out.push_back(sax::Token(alib::Names::GRAMMAR_NON_CONTRACTING_GRAMMAR, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::GRAMMAR_NON_CONTRACTING_GRAMMAR, sax::Token::TokenType::START_ELEMENT);
 
 	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
 	composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
@@ -145,343 +145,343 @@ void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const NonContrac
 	composeRules(out, grammar);
 	composeGeneratesEpsilon(out, grammar.getGeneratesEpsilon());
 
-	out.push_back(sax::Token(alib::Names::GRAMMAR_NON_CONTRACTING_GRAMMAR, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::GRAMMAR_NON_CONTRACTING_GRAMMAR, sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const ContextPreservingUnrestrictedGrammar& grammar) const {
-	out.push_back(sax::Token(alib::Names::GRAMMAR_CONTEXT_PRESERVING_UNRESTRICTED_GRAMMAR, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::GRAMMAR_CONTEXT_PRESERVING_UNRESTRICTED_GRAMMAR, sax::Token::TokenType::START_ELEMENT);
 
 	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
 	composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
 	composeInitialSymbol(out, grammar.getInitialSymbol());
 	composeRules(out, grammar);
 
-	out.push_back(sax::Token(alib::Names::GRAMMAR_CONTEXT_PRESERVING_UNRESTRICTED_GRAMMAR, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::GRAMMAR_CONTEXT_PRESERVING_UNRESTRICTED_GRAMMAR, sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const UnrestrictedGrammar& grammar) const {
-	out.push_back(sax::Token(alib::Names::GRAMMAR_UNRESTRICTED_GRAMMAR, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::GRAMMAR_UNRESTRICTED_GRAMMAR, sax::Token::TokenType::START_ELEMENT);
 
 	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
 	composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
 	composeInitialSymbol(out, grammar.getInitialSymbol());
 	composeRules(out, grammar);
 
-	out.push_back(sax::Token(alib::Names::GRAMMAR_UNRESTRICTED_GRAMMAR, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::GRAMMAR_UNRESTRICTED_GRAMMAR, sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::composeNonterminalAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const {
-	out.push_back(sax::Token("nonterminalAlphabet", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("nonterminalAlphabet", sax::Token::TokenType::START_ELEMENT);
 	for (const auto& symbol : symbols) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 	}
-	out.push_back(sax::Token("nonterminalAlphabet", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("nonterminalAlphabet", sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::composeTerminalAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const {
-	out.push_back(sax::Token("terminalAlphabet", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("terminalAlphabet", sax::Token::TokenType::START_ELEMENT);
 	for (const auto& symbol : symbols) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 	}
-	out.push_back(sax::Token("terminalAlphabet", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("terminalAlphabet", sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::composeInitialSymbol(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) const {
-	out.push_back(sax::Token("initialSymbol", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("initialSymbol", sax::Token::TokenType::START_ELEMENT);
 	alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-	out.push_back(sax::Token("initialSymbol", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("initialSymbol", sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::composeGeneratesEpsilon(std::deque<sax::Token>& out, bool generatesEpsilon) const {
-	out.push_back(sax::Token("generatesEpsilon", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("generatesEpsilon", sax::Token::TokenType::START_ELEMENT);
 	if(generatesEpsilon) {
-		out.push_back(sax::Token("true", sax::Token::TokenType::START_ELEMENT));
-		out.push_back(sax::Token("true", sax::Token::TokenType::END_ELEMENT));
+		out.emplace_back("true", sax::Token::TokenType::START_ELEMENT);
+		out.emplace_back("true", sax::Token::TokenType::END_ELEMENT);
 	} else {
-		out.push_back(sax::Token("false", sax::Token::TokenType::START_ELEMENT));
-		out.push_back(sax::Token("false", sax::Token::TokenType::END_ELEMENT));
+		out.emplace_back("false", sax::Token::TokenType::START_ELEMENT);
+		out.emplace_back("false", sax::Token::TokenType::END_ELEMENT);
 	}
-	out.push_back(sax::Token("generatesEpsilon", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("generatesEpsilon", sax::Token::TokenType::END_ELEMENT);
 }
 
 
 void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const UnrestrictedGrammar& grammar) const {
-	out.push_back(sax::Token("rules", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
 	for (const auto& rule : grammar.getRules()) {
 
 		for(const auto& rhs : rule.second) {
-			out.push_back(sax::Token("rule", sax::Token::TokenType::START_ELEMENT));
+			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
 
 			composeRuleLHS(out, rule.first);
 			composeRuleRHS(out, rhs);
 
-			out.push_back(sax::Token("rule", sax::Token::TokenType::END_ELEMENT));
+			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
 		}
 	}
 
-	out.push_back(sax::Token("rules", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const ContextPreservingUnrestrictedGrammar& grammar) const {
-	out.push_back(sax::Token("rules", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
 	for (const auto& rule : grammar.getRules()) {
 
 		for(const auto& rhs : rule.second) {
-			out.push_back(sax::Token("rule", sax::Token::TokenType::START_ELEMENT));
+			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
 
 			composeRuleLContext(out, std::get<0>(rule.first));
 			composeRuleSingleSymbolLHS(out, std::get<1>(rule.first));
 			composeRuleRContext(out, std::get<2>(rule.first));
 			composeRuleRHS(out, rhs);
 
-			out.push_back(sax::Token("rule", sax::Token::TokenType::END_ELEMENT));
+			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
 		}
 	}
 
-	out.push_back(sax::Token("rules", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const NonContractingGrammar& grammar) const {
-	out.push_back(sax::Token("rules", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
 	for (const auto& rule : grammar.getRules()) {
 
 		for(const auto& rhs : rule.second) {
-			out.push_back(sax::Token("rule", sax::Token::TokenType::START_ELEMENT));
+			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
 
 			composeRuleLHS(out, rule.first);
 			composeRuleRHS(out, rhs);
 
-			out.push_back(sax::Token("rule", sax::Token::TokenType::END_ELEMENT));
+			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
 		}
 	}
 
-	out.push_back(sax::Token("rules", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const CSG& grammar) const {
-	out.push_back(sax::Token("rules", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
 	for (const auto& rule : grammar.getRules()) {
 
 		for(const auto& rhs : rule.second) {
-			out.push_back(sax::Token("rule", sax::Token::TokenType::START_ELEMENT));
+			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
 
 			composeRuleLContext(out, std::get<0>(rule.first));
 			composeRuleSingleSymbolLHS(out, std::get<1>(rule.first));
 			composeRuleRContext(out, std::get<2>(rule.first));
 			composeRuleRHS(out, rhs);
 
-			out.push_back(sax::Token("rule", sax::Token::TokenType::END_ELEMENT));
+			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
 		}
 	}
 
-	out.push_back(sax::Token("rules", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const GNF& grammar) const {
-	out.push_back(sax::Token("rules", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
 	for (const auto& rule : grammar.getRules()) {
 
 		for(const auto& rhs : rule.second) {
-			out.push_back(sax::Token("rule", sax::Token::TokenType::START_ELEMENT));
+			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
 
 			composeRuleSingleSymbolLHS(out, rule.first);
 			composeRuleGNFRHS(out, rhs);
 
-			out.push_back(sax::Token("rule", sax::Token::TokenType::END_ELEMENT));
+			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
 		}
 	}
 
-	out.push_back(sax::Token("rules", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const CNF& grammar) const {
-	out.push_back(sax::Token("rules", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
 	for (const auto& rule : grammar.getRules()) {
 
 		for(const auto& rhs : rule.second) {
-			out.push_back(sax::Token("rule", sax::Token::TokenType::START_ELEMENT));
+			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
 
 			composeRuleSingleSymbolLHS(out, rule.first);
 			composeRuleOneOrTwoSymbolsRHS(out, rhs);
 
-			out.push_back(sax::Token("rule", sax::Token::TokenType::END_ELEMENT));
+			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
 		}
 	}
 
-	out.push_back(sax::Token("rules", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const EpsilonFreeCFG& grammar) const {
-	out.push_back(sax::Token("rules", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
 	for (const auto& rule : grammar.getRules()) {
 
 		for(const auto& rhs : rule.second) {
-			out.push_back(sax::Token("rule", sax::Token::TokenType::START_ELEMENT));
+			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
 
 			composeRuleSingleSymbolLHS(out, rule.first);
 			composeRuleRHS(out, rhs);
 
-			out.push_back(sax::Token("rule", sax::Token::TokenType::END_ELEMENT));
+			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
 		}
 	}
 
-	out.push_back(sax::Token("rules", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const CFG& grammar) const {
-	out.push_back(sax::Token("rules", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
 	for (const auto& rule : grammar.getRules()) {
 
 		for(const auto& rhs : rule.second) {
-			out.push_back(sax::Token("rule", sax::Token::TokenType::START_ELEMENT));
+			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
 
 			composeRuleSingleSymbolLHS(out, rule.first);
 			composeRuleRHS(out, rhs);
 
-			out.push_back(sax::Token("rule", sax::Token::TokenType::END_ELEMENT));
+			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
 		}
 	}
 
-	out.push_back(sax::Token("rules", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const LG& grammar) const {
-	out.push_back(sax::Token("rules", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
 	for (const auto& rule : grammar.getRules()) {
 
 		for(const auto& rhs : rule.second) {
-			out.push_back(sax::Token("rule", sax::Token::TokenType::START_ELEMENT));
+			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
 
 			composeRuleSingleSymbolLHS(out, rule.first);
 			composeRuleLGRHS(out, rhs);
 
-			out.push_back(sax::Token("rule", sax::Token::TokenType::END_ELEMENT));
+			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
 		}
 	}
 
-	out.push_back(sax::Token("rules", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const RightLG& grammar) const {
-	out.push_back(sax::Token("rules", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
 	for (const auto& rule : grammar.getRules()) {
 
 		for(const auto& rhs : rule.second) {
-			out.push_back(sax::Token("rule", sax::Token::TokenType::START_ELEMENT));
+			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
 
 			composeRuleSingleSymbolLHS(out, rule.first);
 			composeRuleRightLGRHS(out, rhs);
 
-			out.push_back(sax::Token("rule", sax::Token::TokenType::END_ELEMENT));
+			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
 		}
 	}
 
-	out.push_back(sax::Token("rules", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const RightRG& grammar) const {
-	out.push_back(sax::Token("rules", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
 	for (const auto& rule : grammar.getRules()) {
 
 		for(const auto& rhs : rule.second) {
-			out.push_back(sax::Token("rule", sax::Token::TokenType::START_ELEMENT));
+			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
 
 			composeRuleSingleSymbolLHS(out, rule.first);
 			composeRuleOneOrTwoSymbolsRHS(out, rhs);
 
-			out.push_back(sax::Token("rule", sax::Token::TokenType::END_ELEMENT));
+			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
 		}
 	}
 
-	out.push_back(sax::Token("rules", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const LeftLG& grammar) const {
-	out.push_back(sax::Token("rules", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
 	for (const auto& rule : grammar.getRules()) {
 
 		for(const auto& rhs : rule.second) {
-			out.push_back(sax::Token("rule", sax::Token::TokenType::START_ELEMENT));
+			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
 
 			composeRuleSingleSymbolLHS(out, rule.first);
 			composeRuleLeftLGRHS(out, rhs);
 
-			out.push_back(sax::Token("rule", sax::Token::TokenType::END_ELEMENT));
+			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
 		}
 	}
 
-	out.push_back(sax::Token("rules", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const LeftRG& grammar) const {
-	out.push_back(sax::Token("rules", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
 	for (const auto& rule : grammar.getRules()) {
 
 		for(const auto& rhs : rule.second) {
-			out.push_back(sax::Token("rule", sax::Token::TokenType::START_ELEMENT));
+			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
 
 			composeRuleSingleSymbolLHS(out, rule.first);
 			composeRuleOneOrTwoSymbolsRHS(out, rhs);
 
-			out.push_back(sax::Token("rule", sax::Token::TokenType::END_ELEMENT));
+			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
 		}
 	}
 
-	out.push_back(sax::Token("rules", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::composeRuleLContext(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) const {
-	out.push_back(sax::Token("lContext", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("lContext", sax::Token::TokenType::START_ELEMENT);
 	if(symbols.size() == 0) {
-		out.push_back(sax::Token("epsilon", sax::Token::TokenType::START_ELEMENT));
-		out.push_back(sax::Token("epsilon", sax::Token::TokenType::END_ELEMENT));
+		out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
+		out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
 	} else for (const auto& symbol : symbols) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 	}
-	out.push_back(sax::Token("lContext", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("lContext", sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::composeRuleLHS(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) const {
-	out.push_back(sax::Token("lhs", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("lhs", sax::Token::TokenType::START_ELEMENT);
 	if(symbols.size() == 0) {
-		out.push_back(sax::Token("epsilon", sax::Token::TokenType::START_ELEMENT));
-		out.push_back(sax::Token("epsilon", sax::Token::TokenType::END_ELEMENT));
+		out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
+		out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
 	} else for (const auto& symbol : symbols) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 	}
-	out.push_back(sax::Token("lhs", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("lhs", sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::composeRuleRContext(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) const {
-	out.push_back(sax::Token("rContext", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("rContext", sax::Token::TokenType::START_ELEMENT);
 	if(symbols.size() == 0) {
-		out.push_back(sax::Token("epsilon", sax::Token::TokenType::START_ELEMENT));
-		out.push_back(sax::Token("epsilon", sax::Token::TokenType::END_ELEMENT));
+		out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
+		out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
 	} else for (const auto& symbol : symbols) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 	}
-	out.push_back(sax::Token("rContext", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("rContext", sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::composeRuleSingleSymbolLHS(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) const {
-	out.push_back(sax::Token("lhs", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("lhs", sax::Token::TokenType::START_ELEMENT);
 	alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-	out.push_back(sax::Token("lhs", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("lhs", sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::composeRuleRHS(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) const {
-	out.push_back(sax::Token("rhs", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
 	if(symbols.size() == 0) {
-		out.push_back(sax::Token("epsilon", sax::Token::TokenType::START_ELEMENT));
-		out.push_back(sax::Token("epsilon", sax::Token::TokenType::END_ELEMENT));
+		out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
+		out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
 	} else for (const auto& symbol : symbols) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 	}
-	out.push_back(sax::Token("rhs", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("rhs", sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::composeRuleOneOrTwoSymbolsRHS(std::deque<sax::Token>& out, const std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>>& symbols) const {
-	out.push_back(sax::Token("rhs", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
 	if(symbols.is<alphabet::Symbol>()) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbols.get<alphabet::Symbol>());
 	} else {
@@ -489,11 +489,11 @@ void GrammarToXMLComposer::composeRuleOneOrTwoSymbolsRHS(std::deque<sax::Token>&
 		alib::xmlApi<alphabet::Symbol>::compose(out, rhs.first);
 		alib::xmlApi<alphabet::Symbol>::compose(out, rhs.second);
 	}
-	out.push_back(sax::Token("rhs", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("rhs", sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::composeRuleGNFRHS(std::deque<sax::Token>& out, const std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>>& symbols) const {
-	out.push_back(sax::Token("rhs", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
 
 	alib::xmlApi<alphabet::Symbol>::compose(out, symbols.first);
 
@@ -501,16 +501,16 @@ void GrammarToXMLComposer::composeRuleGNFRHS(std::deque<sax::Token>& out, const
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 	}
 
-	out.push_back(sax::Token("rhs", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("rhs", sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::composeRuleLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<alphabet::Symbol>, std::tuple<std::vector<alphabet::Symbol>, alphabet::Symbol, std::vector<alphabet::Symbol>>>& symbols) const {
-	out.push_back(sax::Token("rhs", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
 	if(symbols.is<std::vector<alphabet::Symbol>>()) {
 		const std::vector<alphabet::Symbol>& rhs = symbols.get<std::vector<alphabet::Symbol>>();
 		if(rhs.size() == 0) {
-			out.push_back(sax::Token("epsilon", sax::Token::TokenType::START_ELEMENT));
-			out.push_back(sax::Token("epsilon", sax::Token::TokenType::END_ELEMENT));
+			out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
+			out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
 		} else for (const auto& symbol : symbols.get<std::vector<alphabet::Symbol>>()) {
 			alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 		}
@@ -524,16 +524,16 @@ void GrammarToXMLComposer::composeRuleLGRHS(std::deque<sax::Token>& out, const s
 			alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 		}
 	}
-	out.push_back(sax::Token("rhs", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("rhs", sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::composeRuleLeftLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<alphabet::Symbol>, std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>>>& symbols) const {
-	out.push_back(sax::Token("rhs", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
 	if(symbols.is<std::vector<alphabet::Symbol>>()) {
 		const std::vector<alphabet::Symbol>& rhs = symbols.get<std::vector<alphabet::Symbol>>();
 		if(rhs.size() == 0) {
-			out.push_back(sax::Token("epsilon", sax::Token::TokenType::START_ELEMENT));
-			out.push_back(sax::Token("epsilon", sax::Token::TokenType::END_ELEMENT));
+			out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
+			out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
 		} else for (const auto& symbol : symbols.get<std::vector<alphabet::Symbol>>()) {
 			alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 		}
@@ -544,16 +544,16 @@ void GrammarToXMLComposer::composeRuleLeftLGRHS(std::deque<sax::Token>& out, con
 			alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 		}
 	}
-	out.push_back(sax::Token("rhs", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("rhs", sax::Token::TokenType::END_ELEMENT);
 }
 
 void GrammarToXMLComposer::composeRuleRightLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<alphabet::Symbol>, std::pair<std::vector<alphabet::Symbol>, alphabet::Symbol>>& symbols) const {
-	out.push_back(sax::Token("rhs", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
 	if(symbols.is<std::vector<alphabet::Symbol>>()) {
 		const std::vector<alphabet::Symbol>& rhs = symbols.get<std::vector<alphabet::Symbol>>();
 		if(rhs.size() == 0) {
-			out.push_back(sax::Token("epsilon", sax::Token::TokenType::START_ELEMENT));
-			out.push_back(sax::Token("epsilon", sax::Token::TokenType::END_ELEMENT));
+			out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
+			out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
 		} else {
 			for (const auto& symbol : symbols.get<std::vector<alphabet::Symbol>>()) {
 				alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
@@ -566,7 +566,7 @@ void GrammarToXMLComposer::composeRuleRightLGRHS(std::deque<sax::Token>& out, co
 		}
 		alib::xmlApi<alphabet::Symbol>::compose(out, rhs.second);
 	}
-	out.push_back(sax::Token("rhs", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("rhs", sax::Token::TokenType::END_ELEMENT);
 }
 
 } /* namespace grammar */
diff --git a/alib2data/src/graph/GraphToXMLComposer.cpp b/alib2data/src/graph/GraphToXMLComposer.cpp
index d2ab66f617f26f1212752cf53e0c7d6f4f73f795..5bba12af369ee384552b8b9e96a515387c2425e8 100644
--- a/alib2data/src/graph/GraphToXMLComposer.cpp
+++ b/alib2data/src/graph/GraphToXMLComposer.cpp
@@ -10,47 +10,47 @@ void GraphToXMLComposer::Visit(void *data, const Node &node) const
 {
 	std::deque<sax::Token> &out = *static_cast<std::deque<sax::Token>*>(data);
 
-	out.push_back(sax::Token("node", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("node", sax::Token::TokenType::START_ELEMENT);
 	alib::xmlApi<label::Label>::compose(out, node.getName());
-	out.push_back(sax::Token("node", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("node", sax::Token::TokenType::END_ELEMENT);
 }
 
 void GraphToXMLComposer::Visit(void *data, const DirectedEdge &edge) const
 {
 	std::deque<sax::Token> &out = *static_cast<std::deque<sax::Token>*>(data);
 
-	out.push_back(sax::Token("edge", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("edge", sax::Token::TokenType::START_ELEMENT);
 
-	out.push_back(sax::Token("from", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("from", sax::Token::TokenType::START_ELEMENT);
 	edge.getFromNode().Accept(static_cast<void*>(&out), *this);
-	out.push_back(sax::Token("from", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("from", sax::Token::TokenType::END_ELEMENT);
 
 	alib::xmlApi<label::Label>::compose(out, edge.getName());
 
-	out.push_back(sax::Token("to", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("to", sax::Token::TokenType::START_ELEMENT);
 	edge.getToNode().Accept(static_cast<void*>(&out), *this);
-	out.push_back(sax::Token("to", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("to", sax::Token::TokenType::END_ELEMENT);
 
-	out.push_back(sax::Token("edge", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("edge", sax::Token::TokenType::END_ELEMENT);
 }
 
 void GraphToXMLComposer::Visit(void *data, const UndirectedEdge &edge) const
 {
 	std::deque<sax::Token> &out = *static_cast<std::deque<sax::Token>*>(data);
 
-	out.push_back(sax::Token("edge", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("edge", sax::Token::TokenType::START_ELEMENT);
 
-	out.push_back(sax::Token("first", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("first", sax::Token::TokenType::START_ELEMENT);
 	edge.getFirstNode().Accept(static_cast<void*>(&out), *this);
-	out.push_back(sax::Token("first", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("first", sax::Token::TokenType::END_ELEMENT);
 
 	alib::xmlApi<label::Label>::compose(out, edge.getName());
 
-	out.push_back(sax::Token("second", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("second", sax::Token::TokenType::START_ELEMENT);
 	edge.getSecondNode().Accept(static_cast<void*>(&out), *this);
-	out.push_back(sax::Token("second", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("second", sax::Token::TokenType::END_ELEMENT);
 
-	out.push_back(sax::Token("edge", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("edge", sax::Token::TokenType::END_ELEMENT);
 }
 
 void GraphToXMLComposer::compose(std::deque<sax::Token> &out, const GraphBase &graph) const
@@ -65,7 +65,7 @@ void GraphToXMLComposer::compose(std::deque<sax::Token> &out, const Graph &graph
 
 void GraphToXMLComposer::compose(std::deque<sax::Token> &out, const DirectedGraph &graph) const
 {
-	out.push_back(sax::Token(alib::Names::GRAPH_DIRECTED_GRAPH, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::GRAPH_DIRECTED_GRAPH, sax::Token::TokenType::START_ELEMENT);
 
 	composeRepresentation(out, representationToString(graph.getRepresentation()));
 	composeNodes(out, graph.getNodes());
@@ -73,12 +73,12 @@ void GraphToXMLComposer::compose(std::deque<sax::Token> &out, const DirectedGrap
 	composeNodeValues(out, graph);
 	composeEdgeValues(out, graph);
 
-	out.push_back(sax::Token(alib::Names::GRAPH_DIRECTED_GRAPH, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::GRAPH_DIRECTED_GRAPH, sax::Token::TokenType::END_ELEMENT);
 }
 
 void GraphToXMLComposer::compose(std::deque<sax::Token> &out, const UndirectedGraph &graph) const
 {
-	out.push_back(sax::Token(alib::Names::GRAPH_UNDIRECTED_GRAPH, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::GRAPH_UNDIRECTED_GRAPH, sax::Token::TokenType::START_ELEMENT);
 
 	composeRepresentation(out, representationToString(graph.getRepresentation()));
 	composeNodes(out, graph.getNodes());
@@ -86,59 +86,59 @@ void GraphToXMLComposer::compose(std::deque<sax::Token> &out, const UndirectedGr
 	composeNodeValues(out, graph);
 	composeEdgeValues(out, graph);
 
-	out.push_back(sax::Token(alib::Names::GRAPH_UNDIRECTED_GRAPH, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::GRAPH_UNDIRECTED_GRAPH, sax::Token::TokenType::END_ELEMENT);
 }
 
 void GraphToXMLComposer::composeRepresentation(std::deque<sax::Token> &out, const std::string &representation) const
 {
-	out.push_back(sax::Token("representation", sax::Token::TokenType::START_ELEMENT));
-	out.push_back(sax::Token(representation, sax::Token::TokenType::CHARACTER));
-	out.push_back(sax::Token("representation", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("representation", sax::Token::TokenType::START_ELEMENT);
+	out.emplace_back(representation, sax::Token::TokenType::CHARACTER);
+	out.emplace_back("representation", sax::Token::TokenType::END_ELEMENT);
 }
 
 void GraphToXMLComposer::composeNodes(std::deque<sax::Token> &out, const std::set<Node> &nodes) const
 {
-	out.push_back(sax::Token("nodes", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("nodes", sax::Token::TokenType::START_ELEMENT);
 	for (const Node &node : nodes) {
 		node.Accept(static_cast<void*>(&out), *this);
 	}
-	out.push_back(sax::Token("nodes", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("nodes", sax::Token::TokenType::END_ELEMENT);
 }
 
 template<typename T>
 void GraphToXMLComposer::composeEdges(std::deque<sax::Token> &out, const std::set<T> &edges) const
 {
-	out.push_back(sax::Token("edges", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("edges", sax::Token::TokenType::START_ELEMENT);
 	for (const auto &edge : edges) {
 		edge.Accept(static_cast<void*>(&out), *this);
 	}
-	out.push_back(sax::Token("edges", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("edges", sax::Token::TokenType::END_ELEMENT);
 }
 
 template<typename T>
 void GraphToXMLComposer::composeNodeValues(std::deque<sax::Token> &out, const T &graph) const
 {
-	out.push_back(sax::Token("nodevalues", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("nodevalues", sax::Token::TokenType::START_ELEMENT);
 	for (auto i : graph.nodeValues) {
 		i.first.Accept(static_cast<void*>(&out), *this);
-		out.push_back(sax::Token("value", sax::Token::TokenType::START_ELEMENT));
-		out.push_back(sax::Token(std::itos(i.second), sax::Token::TokenType::CHARACTER));
-		out.push_back(sax::Token("value", sax::Token::TokenType::END_ELEMENT));
+		out.emplace_back("value", sax::Token::TokenType::START_ELEMENT);
+		out.emplace_back(std::itos(i.second), sax::Token::TokenType::CHARACTER);
+		out.emplace_back("value", sax::Token::TokenType::END_ELEMENT);
 	}
-	out.push_back(sax::Token("nodevalues", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("nodevalues", sax::Token::TokenType::END_ELEMENT);
 }
 
 template<typename T>
 void GraphToXMLComposer::composeEdgeValues(std::deque<sax::Token> &out, const T &graph) const
 {
-	out.push_back(sax::Token("edgevalues", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("edgevalues", sax::Token::TokenType::START_ELEMENT);
 	for (auto &i : graph.edgeValues) {
 		i.first.Accept(static_cast<void*>(&out), *this);
-		out.push_back(sax::Token("value", sax::Token::TokenType::START_ELEMENT));
-		out.push_back(sax::Token(std::itos(i.second), sax::Token::TokenType::CHARACTER));
-		out.push_back(sax::Token("value", sax::Token::TokenType::END_ELEMENT));
+		out.emplace_back("value", sax::Token::TokenType::START_ELEMENT);
+		out.emplace_back(std::itos(i.second), sax::Token::TokenType::CHARACTER);
+		out.emplace_back("value", sax::Token::TokenType::END_ELEMENT);
 	}
-	out.push_back(sax::Token("edgevalues", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("edgevalues", sax::Token::TokenType::END_ELEMENT);
 }
 
 } // namespace graph
diff --git a/alib2data/src/label/LabelToXMLComposer.cpp b/alib2data/src/label/LabelToXMLComposer.cpp
index b59ef2cdd7db5e47c09317fa7e82668d4a6ee4e1..b8672a5b05459cbdf03281704d10385711d6c9e1 100644
--- a/alib2data/src/label/LabelToXMLComposer.cpp
+++ b/alib2data/src/label/LabelToXMLComposer.cpp
@@ -21,43 +21,43 @@ void LabelToXMLComposer::compose(std::deque<sax::Token>& out, const LabelBase& l
 }
 
 void LabelToXMLComposer::compose(std::deque<sax::Token>& out, const PrimitiveLabel& label) const {
-	out.push_back(sax::Token(alib::Names::LABEL_PRIMITIVE_LABEL, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::LABEL_PRIMITIVE_LABEL, sax::Token::TokenType::START_ELEMENT);
 	alib::xmlApi<primitive::Primitive>::compose(out, label.getData());
-	out.push_back(sax::Token(alib::Names::LABEL_PRIMITIVE_LABEL, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::LABEL_PRIMITIVE_LABEL, sax::Token::TokenType::END_ELEMENT);
 }
 
 void LabelToXMLComposer::compose(std::deque<sax::Token>& out, const HexavigesimalLabel& label) const {
-	out.push_back(sax::Token(alib::Names::LABEL_HEXAVIGESIMAL_LABEL, sax::Token::TokenType::START_ELEMENT));
-	out.push_back(sax::Token(std::itos(label.getData()), sax::Token::TokenType::CHARACTER));
-	out.push_back(sax::Token(alib::Names::LABEL_HEXAVIGESIMAL_LABEL, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::LABEL_HEXAVIGESIMAL_LABEL, sax::Token::TokenType::START_ELEMENT);
+	out.emplace_back(std::itos(label.getData()), sax::Token::TokenType::CHARACTER);
+	out.emplace_back(alib::Names::LABEL_HEXAVIGESIMAL_LABEL, sax::Token::TokenType::END_ELEMENT);
 }
 
 void LabelToXMLComposer::compose(std::deque<sax::Token>& out, const ObjectLabel& label) const {
-	out.push_back(sax::Token(alib::Names::LABEL_OBJECT_LABEL, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::LABEL_OBJECT_LABEL, sax::Token::TokenType::START_ELEMENT);
 	alib::xmlApi<alib::Object>::compose(out, label.getData());
-	out.push_back(sax::Token(alib::Names::LABEL_OBJECT_LABEL, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::LABEL_OBJECT_LABEL, sax::Token::TokenType::END_ELEMENT);
 }
 
 void LabelToXMLComposer::compose(std::deque<sax::Token>& out, const LabelSetLabel& label) const {
-	out.push_back(sax::Token(alib::Names::LABEL_LABEL_SET_LABEL, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::LABEL_LABEL_SET_LABEL, sax::Token::TokenType::START_ELEMENT);
 	for(const Label& innerLabel : label.getData()) {
 		alib::xmlApi<label::Label>::compose(out, innerLabel);
 	}
-	out.push_back(sax::Token(alib::Names::LABEL_LABEL_SET_LABEL, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::LABEL_LABEL_SET_LABEL, sax::Token::TokenType::END_ELEMENT);
 }
 
 void LabelToXMLComposer::compose(std::deque<sax::Token>& out, const LabelPairLabel& label) const {
-	out.push_back(sax::Token(alib::Names::LABEL_LABEL_PAIR_LABEL, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::LABEL_LABEL_PAIR_LABEL, sax::Token::TokenType::START_ELEMENT);
 	alib::xmlApi<label::Label>::compose(out, label.getData().first);
 	alib::xmlApi<label::Label>::compose(out, label.getData().second);
-	out.push_back(sax::Token(alib::Names::LABEL_LABEL_PAIR_LABEL, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::LABEL_LABEL_PAIR_LABEL, sax::Token::TokenType::END_ELEMENT);
 }
 
 void LabelToXMLComposer::compose(std::deque<sax::Token>& out, const UniqueLabel& label) const {
-	out.push_back(sax::Token(alib::Names::LABEL_UNIQUE_LABEL, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::LABEL_UNIQUE_LABEL, sax::Token::TokenType::START_ELEMENT);
 	alib::xmlApi<label::Label>::compose(out, label.getLabel());
 	alib::xmlApi<primitive::Integer>::compose(out, label.getId());
-	out.push_back(sax::Token(alib::Names::LABEL_UNIQUE_LABEL, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::LABEL_UNIQUE_LABEL, sax::Token::TokenType::END_ELEMENT);
 }
 
 } /* namespace label */
diff --git a/alib2data/src/object/ObjectToXMLComposer.cpp b/alib2data/src/object/ObjectToXMLComposer.cpp
index 7e080122a7b73abfb1b8532620806f22ba9f89de..33093f83858896731a002d82943e952c2782239e 100644
--- a/alib2data/src/object/ObjectToXMLComposer.cpp
+++ b/alib2data/src/object/ObjectToXMLComposer.cpp
@@ -16,8 +16,8 @@ void ObjectToXMLComposer::compose(std::deque<sax::Token>& out, const Object& obj
 }
 
 void ObjectToXMLComposer::compose(std::deque<sax::Token>& out, const Void&) const {
-	out.push_back(sax::Token(alib::Names::ALIB_VOID, sax::Token::TokenType::START_ELEMENT));
-	out.push_back(sax::Token(alib::Names::ALIB_VOID, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::ALIB_VOID, sax::Token::TokenType::START_ELEMENT);
+	out.emplace_back(alib::Names::ALIB_VOID, sax::Token::TokenType::END_ELEMENT);
 }
 
 void ObjectToXMLComposer::compose(std::deque<sax::Token>& out, const ObjectBase& object) const {
diff --git a/alib2data/src/primitive/PrimitiveToXMLComposer.cpp b/alib2data/src/primitive/PrimitiveToXMLComposer.cpp
index 120ddf6d80949f5cf150207414006ae2761d5329..da87f5b4e4d5beb83b01667fcdd7df966e5c9d57 100644
--- a/alib2data/src/primitive/PrimitiveToXMLComposer.cpp
+++ b/alib2data/src/primitive/PrimitiveToXMLComposer.cpp
@@ -25,69 +25,69 @@ void PrimitiveToXMLComposer::compose(std::deque<sax::Token>& out, const Primitiv
 }
 
 void PrimitiveToXMLComposer::compose(std::deque<sax::Token>& out, const Integer& primitive) const {
-	out.push_back(sax::Token(alib::Names::PRIMITIVE_INTEGER, sax::Token::TokenType::START_ELEMENT));
-	out.push_back(sax::Token(std::itos(primitive.getData()), sax::Token::TokenType::CHARACTER));
-	out.push_back(sax::Token(alib::Names::PRIMITIVE_INTEGER, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::PRIMITIVE_INTEGER, sax::Token::TokenType::START_ELEMENT);
+	out.emplace_back(std::itos(primitive.getData()), sax::Token::TokenType::CHARACTER);
+	out.emplace_back(alib::Names::PRIMITIVE_INTEGER, sax::Token::TokenType::END_ELEMENT);
 }
 
 void PrimitiveToXMLComposer::compose(std::deque<sax::Token>& out, const Character& primitive) const {
-	out.push_back(sax::Token(alib::Names::PRIMITIVE_CHARACTER, sax::Token::TokenType::START_ELEMENT));
-	out.push_back(sax::Token(std::string(1, primitive.getData()), sax::Token::TokenType::CHARACTER));
-	out.push_back(sax::Token(alib::Names::PRIMITIVE_CHARACTER, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::PRIMITIVE_CHARACTER, sax::Token::TokenType::START_ELEMENT);
+	out.emplace_back(std::string(1, primitive.getData()), sax::Token::TokenType::CHARACTER);
+	out.emplace_back(alib::Names::PRIMITIVE_CHARACTER, sax::Token::TokenType::END_ELEMENT);
 }
 
 void PrimitiveToXMLComposer::compose(std::deque<sax::Token>& out, const Unsigned& primitive) const {
-	out.push_back(sax::Token(alib::Names::PRIMITIVE_UNSIGNED, sax::Token::TokenType::START_ELEMENT));
-	out.push_back(sax::Token(std::utos(primitive.getData()), sax::Token::TokenType::CHARACTER));
-	out.push_back(sax::Token(alib::Names::PRIMITIVE_UNSIGNED, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::PRIMITIVE_UNSIGNED, sax::Token::TokenType::START_ELEMENT);
+	out.emplace_back(std::utos(primitive.getData()), sax::Token::TokenType::CHARACTER);
+	out.emplace_back(alib::Names::PRIMITIVE_UNSIGNED, sax::Token::TokenType::END_ELEMENT);
 }
 
 void PrimitiveToXMLComposer::compose(std::deque<sax::Token>& out, const Bool& primitive) const {
-	out.push_back(sax::Token(alib::Names::PRIMITIVE_BOOL, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::PRIMITIVE_BOOL, sax::Token::TokenType::START_ELEMENT);
 	if(primitive.getData())
-		out.push_back(sax::Token("true", sax::Token::TokenType::CHARACTER));
+		out.emplace_back("true", sax::Token::TokenType::CHARACTER);
 	else
-		out.push_back(sax::Token("false", sax::Token::TokenType::CHARACTER));
-	out.push_back(sax::Token(alib::Names::PRIMITIVE_BOOL, sax::Token::TokenType::END_ELEMENT));
+		out.emplace_back("false", sax::Token::TokenType::CHARACTER);
+	out.emplace_back(alib::Names::PRIMITIVE_BOOL, sax::Token::TokenType::END_ELEMENT);
 }
 
 void PrimitiveToXMLComposer::compose(std::deque<sax::Token>& out, const String& primitive) const {
-	out.push_back(sax::Token(alib::Names::PRIMITIVE_STRING, sax::Token::TokenType::START_ELEMENT));
-	out.push_back(sax::Token(primitive.getData(), sax::Token::TokenType::CHARACTER));
-	out.push_back(sax::Token(alib::Names::PRIMITIVE_STRING, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::PRIMITIVE_STRING, sax::Token::TokenType::START_ELEMENT);
+	out.emplace_back(primitive.getData(), sax::Token::TokenType::CHARACTER);
+	out.emplace_back(alib::Names::PRIMITIVE_STRING, sax::Token::TokenType::END_ELEMENT);
 }
 
 void PrimitiveToXMLComposer::compose(std::deque<sax::Token>& out, int primitive) const {
-	out.push_back(sax::Token(alib::Names::PRIMITIVE_INTEGER, sax::Token::TokenType::START_ELEMENT));
-	out.push_back(sax::Token(std::itos(primitive), sax::Token::TokenType::CHARACTER));
-	out.push_back(sax::Token(alib::Names::PRIMITIVE_INTEGER, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::PRIMITIVE_INTEGER, sax::Token::TokenType::START_ELEMENT);
+	out.emplace_back(std::itos(primitive), sax::Token::TokenType::CHARACTER);
+	out.emplace_back(alib::Names::PRIMITIVE_INTEGER, sax::Token::TokenType::END_ELEMENT);
 }
 
 void PrimitiveToXMLComposer::compose(std::deque<sax::Token>& out, char primitive) const {
-	out.push_back(sax::Token(alib::Names::PRIMITIVE_CHARACTER, sax::Token::TokenType::START_ELEMENT));
-	out.push_back(sax::Token(std::string(1, primitive), sax::Token::TokenType::CHARACTER));
-	out.push_back(sax::Token(alib::Names::PRIMITIVE_CHARACTER, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::PRIMITIVE_CHARACTER, sax::Token::TokenType::START_ELEMENT);
+	out.emplace_back(std::string(1, primitive), sax::Token::TokenType::CHARACTER);
+	out.emplace_back(alib::Names::PRIMITIVE_CHARACTER, sax::Token::TokenType::END_ELEMENT);
 }
 
 void PrimitiveToXMLComposer::compose(std::deque<sax::Token>& out, const std::string& primitive) const {
-	out.push_back(sax::Token(alib::Names::PRIMITIVE_STRING, sax::Token::TokenType::START_ELEMENT));
-	out.push_back(sax::Token(primitive, sax::Token::TokenType::CHARACTER));
-	out.push_back(sax::Token(alib::Names::PRIMITIVE_STRING, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::PRIMITIVE_STRING, sax::Token::TokenType::START_ELEMENT);
+	out.emplace_back(primitive, sax::Token::TokenType::CHARACTER);
+	out.emplace_back(alib::Names::PRIMITIVE_STRING, sax::Token::TokenType::END_ELEMENT);
 }
 
 void PrimitiveToXMLComposer::compose(std::deque<sax::Token>& out, unsigned primitive) const {
-	out.push_back(sax::Token(alib::Names::PRIMITIVE_UNSIGNED, sax::Token::TokenType::START_ELEMENT));
-	out.push_back(sax::Token(std::utos(primitive), sax::Token::TokenType::CHARACTER));
-	out.push_back(sax::Token(alib::Names::PRIMITIVE_UNSIGNED, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::PRIMITIVE_UNSIGNED, sax::Token::TokenType::START_ELEMENT);
+	out.emplace_back(std::utos(primitive), sax::Token::TokenType::CHARACTER);
+	out.emplace_back(alib::Names::PRIMITIVE_UNSIGNED, sax::Token::TokenType::END_ELEMENT);
 }
 
 void PrimitiveToXMLComposer::compose(std::deque<sax::Token>& out, bool primitive) const {
-	out.push_back(sax::Token(alib::Names::PRIMITIVE_BOOL, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::PRIMITIVE_BOOL, sax::Token::TokenType::START_ELEMENT);
 	if(primitive)
-		out.push_back(sax::Token("true", sax::Token::TokenType::CHARACTER));
+		out.emplace_back("true", sax::Token::TokenType::CHARACTER);
 	else
-		out.push_back(sax::Token("false", sax::Token::TokenType::CHARACTER));
-	out.push_back(sax::Token(alib::Names::PRIMITIVE_BOOL, sax::Token::TokenType::END_ELEMENT));
+		out.emplace_back("false", sax::Token::TokenType::CHARACTER);
+	out.emplace_back(alib::Names::PRIMITIVE_BOOL, sax::Token::TokenType::END_ELEMENT);
 }
 
 } /* namespace primitive */
diff --git a/alib2data/src/regexp/RegExpToXMLComposer.cpp b/alib2data/src/regexp/RegExpToXMLComposer.cpp
index b83a9219cf379fc4adbecdfcb87227fdd390f915..9f5175893a0cbd3c165ac508b667981ea9313d42 100644
--- a/alib2data/src/regexp/RegExpToXMLComposer.cpp
+++ b/alib2data/src/regexp/RegExpToXMLComposer.cpp
@@ -14,30 +14,30 @@ namespace regexp {
 void RegExpToXMLComposer::Visit(void* userData, const UnboundedRegExpAlternation& alternation) const {
 	std::deque<sax::Token> &out = *((std::deque<sax::Token>*) userData);
 
-	out.push_back(sax::Token("alternation", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("alternation", sax::Token::TokenType::START_ELEMENT);
 	for (const auto& element : alternation.getElements()) {
 		element->Accept(userData, *this);
 	}
-	out.push_back(sax::Token("alternation", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("alternation", sax::Token::TokenType::END_ELEMENT);
 }
 
 void RegExpToXMLComposer::Visit(void* userData, const UnboundedRegExpConcatenation& concatenation) const {
 	std::deque<sax::Token> &out = *((std::deque<sax::Token>*) userData);
 
-	out.push_back(sax::Token("concatenation", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("concatenation", sax::Token::TokenType::START_ELEMENT);
 	for (auto element : concatenation.getElements()) {
 		element->Accept(userData, *this);
 	}
-	out.push_back(sax::Token("concatenation", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("concatenation", sax::Token::TokenType::END_ELEMENT);
 
 }
 
 void RegExpToXMLComposer::Visit(void* userData, const UnboundedRegExpIteration& iteration) const {
 	std::deque<sax::Token> &out = *((std::deque<sax::Token>*) userData);
 
-	out.push_back(sax::Token("iteration", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("iteration", sax::Token::TokenType::START_ELEMENT);
 	iteration.getElement().Accept(userData, *this);
-	out.push_back(sax::Token("iteration", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("iteration", sax::Token::TokenType::END_ELEMENT);
 }
 
 void RegExpToXMLComposer::Visit(void* userData, const UnboundedRegExpSymbol& symbol) const {
@@ -49,42 +49,42 @@ void RegExpToXMLComposer::Visit(void* userData, const UnboundedRegExpSymbol& sym
 void RegExpToXMLComposer::Visit(void* userData, const UnboundedRegExpEpsilon&) const {
 	std::deque<sax::Token> &out = *((std::deque<sax::Token>*) userData);
 
-	out.push_back(sax::Token("epsilon", sax::Token::TokenType::START_ELEMENT));
-	out.push_back(sax::Token("epsilon", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
+	out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
 }
 
 void RegExpToXMLComposer::Visit(void* userData, const UnboundedRegExpEmpty&) const {
 	std::deque<sax::Token> &out = *((std::deque<sax::Token>*) userData);
 
-	out.push_back(sax::Token("empty", sax::Token::TokenType::START_ELEMENT));
-	out.push_back(sax::Token("empty", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("empty", sax::Token::TokenType::START_ELEMENT);
+	out.emplace_back("empty", sax::Token::TokenType::END_ELEMENT);
 }
 
 void RegExpToXMLComposer::Visit(void* userData, const FormalRegExpAlternation& alternation) const {
 	std::deque<sax::Token> &out = *((std::deque<sax::Token>*) userData);
 
-	out.push_back(sax::Token("alternation", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("alternation", sax::Token::TokenType::START_ELEMENT);
 	alternation.getLeftElement().Accept(userData, *this);
 	alternation.getRightElement().Accept(userData, *this);
-	out.push_back(sax::Token("alternation", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("alternation", sax::Token::TokenType::END_ELEMENT);
 }
 
 void RegExpToXMLComposer::Visit(void* userData, const FormalRegExpConcatenation& concatenation) const {
 	std::deque<sax::Token> &out = *((std::deque<sax::Token>*) userData);
 
-	out.push_back(sax::Token("concatenation", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("concatenation", sax::Token::TokenType::START_ELEMENT);
 	concatenation.getLeftElement().Accept(userData, *this);
 	concatenation.getRightElement().Accept(userData, *this);
-	out.push_back(sax::Token("concatenation", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("concatenation", sax::Token::TokenType::END_ELEMENT);
 
 }
 
 void RegExpToXMLComposer::Visit(void* userData, const FormalRegExpIteration& iteration) const {
 	std::deque<sax::Token> &out = *((std::deque<sax::Token>*) userData);
 
-	out.push_back(sax::Token("iteration", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("iteration", sax::Token::TokenType::START_ELEMENT);
 	iteration.getElement().Accept(userData, *this);
-	out.push_back(sax::Token("iteration", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("iteration", sax::Token::TokenType::END_ELEMENT);
 }
 
 void RegExpToXMLComposer::Visit(void* userData, const FormalRegExpSymbol& symbol) const {
@@ -96,15 +96,15 @@ void RegExpToXMLComposer::Visit(void* userData, const FormalRegExpSymbol& symbol
 void RegExpToXMLComposer::Visit(void* userData, const FormalRegExpEpsilon&) const {
 	std::deque<sax::Token> &out = *((std::deque<sax::Token>*) userData);
 
-	out.push_back(sax::Token("epsilon", sax::Token::TokenType::START_ELEMENT));
-	out.push_back(sax::Token("epsilon", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
+	out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
 }
 
 void RegExpToXMLComposer::Visit(void* userData, const FormalRegExpEmpty&) const {
 	std::deque<sax::Token> &out = *((std::deque<sax::Token>*) userData);
 
-	out.push_back(sax::Token("empty", sax::Token::TokenType::START_ELEMENT));
-	out.push_back(sax::Token("empty", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("empty", sax::Token::TokenType::START_ELEMENT);
+	out.emplace_back("empty", sax::Token::TokenType::END_ELEMENT);
 }
 
 void RegExpToXMLComposer::compose(std::deque<sax::Token>& out, const RegExp& regexp) const {
@@ -116,29 +116,29 @@ void RegExpToXMLComposer::compose(std::deque<sax::Token>& out, const RegExpBase&
 }
 
 void RegExpToXMLComposer::compose(std::deque<sax::Token>& out, const UnboundedRegExp& regexp) const {
-	out.push_back(sax::Token(alib::Names::REGEXP_UNBOUNDED_REGEXP, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::REGEXP_UNBOUNDED_REGEXP, sax::Token::TokenType::START_ELEMENT);
 	{
-		out.push_back(sax::Token("alphabet", sax::Token::TokenType::START_ELEMENT));
+		out.emplace_back("alphabet", sax::Token::TokenType::START_ELEMENT);
 		for (const auto& symbol: regexp.getAlphabet()) {
 			alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 		}
-		out.push_back(sax::Token("alphabet", sax::Token::TokenType::END_ELEMENT));
+		out.emplace_back("alphabet", sax::Token::TokenType::END_ELEMENT);
 	}
 	regexp.getRegExp().Accept((void*) &out, *this);
-	out.push_back(sax::Token(alib::Names::REGEXP_UNBOUNDED_REGEXP, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::REGEXP_UNBOUNDED_REGEXP, sax::Token::TokenType::END_ELEMENT);
 }
 
 void RegExpToXMLComposer::compose(std::deque<sax::Token>& out, const FormalRegExp& regexp) const {
-	out.push_back(sax::Token(alib::Names::REGEXP_FORMAL_REGEXP, sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::REGEXP_FORMAL_REGEXP, sax::Token::TokenType::START_ELEMENT);
 	{
-		out.push_back(sax::Token("alphabet", sax::Token::TokenType::START_ELEMENT));
+		out.emplace_back("alphabet", sax::Token::TokenType::START_ELEMENT);
 		for (const auto& symbol: regexp.getAlphabet()) {
 			alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 		}
-		out.push_back(sax::Token("alphabet", sax::Token::TokenType::END_ELEMENT));
+		out.emplace_back("alphabet", sax::Token::TokenType::END_ELEMENT);
 	}
 	regexp.getRegExp().Accept((void*) &out, *this);
-	out.push_back(sax::Token(alib::Names::REGEXP_FORMAL_REGEXP, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(alib::Names::REGEXP_FORMAL_REGEXP, sax::Token::TokenType::END_ELEMENT);
 }
 
 } /* namespace regexp */
diff --git a/alib2data/src/sax/SaxParseInterface.cpp b/alib2data/src/sax/SaxParseInterface.cpp
index bc7279c40d22851199e409d329f27ac5ce0638f8..7f08b2f2cc850d3a13eb81d46b72b41094534fa9 100644
--- a/alib2data/src/sax/SaxParseInterface.cpp
+++ b/alib2data/src/sax/SaxParseInterface.cpp
@@ -62,26 +62,26 @@ void SaxParseInterface::characters(void * userData, const xmlChar * ch, int len)
 	std::deque<Token> &out = *((std::deque<Token>*) userData);
 	std::string tmp((const char*) ch, len);
 
-	if(! std::all_of(tmp.begin(), tmp.end(), isspace)) out.push_back(Token(std::move(tmp), Token::TokenType::CHARACTER));
+	if(! std::all_of(tmp.begin(), tmp.end(), isspace)) out.emplace_back(std::move(tmp), Token::TokenType::CHARACTER);
 }
 
 void SaxParseInterface::startElement(void* userData, const xmlChar* name, const xmlChar** attrs) {
 	std::deque<Token> &out = *((std::deque<Token>*) userData);
-	out.push_back(Token((const char*) name, Token::TokenType::START_ELEMENT));
+	out.emplace_back(Token((const char*) name, Token::TokenType::START_ELEMENT));
 
 	while(attrs && *attrs && *(attrs+1)) {
-		out.push_back(Token((const char*) *attrs, Token::TokenType::START_ATTRIBUTE));
+		out.emplace_back((const char*) *attrs, Token::TokenType::START_ATTRIBUTE);
 
-		out.push_back(Token((const char*) *(attrs + 1), Token::TokenType::CHARACTER));
+		out.emplace_back((const char*) *(attrs + 1), Token::TokenType::CHARACTER);
 
-		out.push_back(Token((const char*) *attrs, Token::TokenType::END_ATTRIBUTE));
+		out.emplace_back((const char*) *attrs, Token::TokenType::END_ATTRIBUTE);
 		attrs+=2;
 	}
 }
 
 void SaxParseInterface::endElement(void * userData, const xmlChar * name) {
 	std::deque<Token> &out = *((std::deque<Token>*) userData);
-	out.push_back(Token((const  char*) name, Token::TokenType::END_ELEMENT));
+	out.emplace_back((const  char*) name, Token::TokenType::END_ELEMENT);
 }
 
 } /* namespace sax */
diff --git a/alib2data/src/string/StringToXMLComposer.cpp b/alib2data/src/string/StringToXMLComposer.cpp
index 1a69ab25ad618510bba856c5826c3a8bd9d3fdd2..b0498177b6a240e5f3c85eff0124711b5a1f81e3 100644
--- a/alib2data/src/string/StringToXMLComposer.cpp
+++ b/alib2data/src/string/StringToXMLComposer.cpp
@@ -23,45 +23,45 @@ void StringToXMLComposer::compose(std::deque<sax::Token>& out, const StringBase&
 }
 
 void StringToXMLComposer::compose(std::deque<sax::Token>& out, const LinearString& string) const {
-	out.push_back(sax::Token(alib::Names::STRING_LINEAR_STRING, sax::Token::TokenType::START_ELEMENT));
-	out.push_back(sax::Token("alphabet", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::STRING_LINEAR_STRING, sax::Token::TokenType::START_ELEMENT);
+	out.emplace_back("alphabet", sax::Token::TokenType::START_ELEMENT);
 	for (const auto& symbol: string.getAlphabet()) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 	}
-	out.push_back(sax::Token("alphabet", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("alphabet", sax::Token::TokenType::END_ELEMENT);
 
-	out.push_back(sax::Token("content", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("content", sax::Token::TokenType::START_ELEMENT);
 	for(const auto& symbol : string.getContent()) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 	}
-	out.push_back(sax::Token("content", sax::Token::TokenType::END_ELEMENT));
-	out.push_back(sax::Token(alib::Names::STRING_LINEAR_STRING, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("content", sax::Token::TokenType::END_ELEMENT);
+	out.emplace_back(alib::Names::STRING_LINEAR_STRING, sax::Token::TokenType::END_ELEMENT);
 }
 
 void StringToXMLComposer::compose(std::deque<sax::Token>& out, const CyclicString& string) const {
-	out.push_back(sax::Token(alib::Names::STRING_CYCLIC_STRING, sax::Token::TokenType::START_ELEMENT));
-	out.push_back(sax::Token("alphabet", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::STRING_CYCLIC_STRING, sax::Token::TokenType::START_ELEMENT);
+	out.emplace_back("alphabet", sax::Token::TokenType::START_ELEMENT);
 	for (const auto& symbol: string.getAlphabet()) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 	}
-	out.push_back(sax::Token("alphabet", sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("alphabet", sax::Token::TokenType::END_ELEMENT);
 
-	out.push_back(sax::Token("content", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back("content", sax::Token::TokenType::START_ELEMENT);
 	for(const auto& symbol : string.getContent()) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 	}
-	out.push_back(sax::Token("content", sax::Token::TokenType::END_ELEMENT));
-	out.push_back(sax::Token(alib::Names::STRING_CYCLIC_STRING, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("content", sax::Token::TokenType::END_ELEMENT);
+	out.emplace_back(alib::Names::STRING_CYCLIC_STRING, sax::Token::TokenType::END_ELEMENT);
 }
 
 void StringToXMLComposer::compose(std::deque<sax::Token>& out, const Epsilon& string) const {
-	out.push_back(sax::Token(alib::Names::STRING_EPSILON, sax::Token::TokenType::START_ELEMENT));
-	out.push_back(sax::Token("alphabet", sax::Token::TokenType::START_ELEMENT));
+	out.emplace_back(alib::Names::STRING_EPSILON, sax::Token::TokenType::START_ELEMENT);
+	out.emplace_back("alphabet", sax::Token::TokenType::START_ELEMENT);
 	for (const auto& symbol: string.getAlphabet()) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 	}
-	out.push_back(sax::Token("alphabet", sax::Token::TokenType::END_ELEMENT));
-	out.push_back(sax::Token(alib::Names::STRING_EPSILON, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back("alphabet", sax::Token::TokenType::END_ELEMENT);
+	out.emplace_back(alib::Names::STRING_EPSILON, sax::Token::TokenType::END_ELEMENT);
 }
 
 } /* namespace string */