From 520302bcc759c365b79e4c18279da12a9de3819c Mon Sep 17 00:00:00 2001
From: Jan Travnicek <Jan.Travnicek@fit.cvut.cz>
Date: Sat, 6 Jun 2015 16:18:56 +0200
Subject: [PATCH] -pop_front +iterator in xml parsing

---
 acompare2/src/acompare.cpp                    |   4 +-
 alib2data/src/XmlApi.cpp                      | 372 +++++++--------
 alib2data/src/XmlApi.hpp                      | 426 +++++++++---------
 .../src/alphabet/SymbolFromXMLParser.cpp      |  32 +-
 alib2data/src/alphabet/SymbolFromXMLParser.h  |  30 +-
 .../src/automaton/AutomatonFromXMLParser.cpp  | 160 +++----
 .../src/automaton/AutomatonFromXMLParser.h    | 172 +++----
 .../src/container/ContainerFromXMLParser.cpp  |  16 +-
 .../src/container/ContainerFromXMLParser.hpp  |  38 +-
 .../src/exception/ExceptionFromXMLParser.cpp  |  18 +-
 .../src/exception/ExceptionFromXMLParser.h    |   6 +-
 alib2data/src/factory/XmlDataFactory.hpp      |  22 +-
 .../src/grammar/GrammarFromXMLParser.cpp      |  94 ++--
 alib2data/src/grammar/GrammarFromXMLParser.h  |  90 ++--
 alib2data/src/graph/GraphFromXMLParser.cpp    |  30 +-
 alib2data/src/graph/GraphFromXMLParser.h      |  30 +-
 alib2data/src/label/LabelFromXMLParser.cpp    |  20 +-
 alib2data/src/label/LabelFromXMLParser.h      |  18 +-
 alib2data/src/object/ObjectFromXMLParser.cpp  |   6 +-
 alib2data/src/object/ObjectFromXMLParser.h    |   6 +-
 .../src/primitive/PrimitiveFromXMLParser.cpp  |  28 +-
 .../src/primitive/PrimitiveFromXMLParser.h    |  26 +-
 alib2data/src/regexp/RegExpFromXMLParser.cpp  |  38 +-
 alib2data/src/regexp/RegExpFromXMLParser.h    |  38 +-
 alib2data/src/sax/FromXMLParserHelper.cpp     |  24 +-
 alib2data/src/sax/FromXMLParserHelper.h       |   8 +-
 alib2data/src/sax/Token.cpp                   |   2 +-
 alib2data/src/sax/Token.h                     |   2 +-
 alib2data/src/string/StringFromXMLParser.cpp  |  18 +-
 alib2data/src/string/StringFromXMLParser.h    |  16 +-
 alib2data/src/tree/TreeFromRawParser.cpp      |   8 +-
 alib2data/src/tree/TreeFromRawParser.h        |   8 +-
 alib2data/src/tree/TreeFromXMLParser.cpp      |  40 +-
 alib2data/src/tree/TreeFromXMLParser.h        |  38 +-
 araw2/src/araw.cpp                            |   3 +-
 35 files changed, 946 insertions(+), 941 deletions(-)

diff --git a/acompare2/src/acompare.cpp b/acompare2/src/acompare.cpp
index 31b7dd18c5..36e8fa8bd4 100644
--- a/acompare2/src/acompare.cpp
+++ b/acompare2/src/acompare.cpp
@@ -57,14 +57,14 @@ int main(int argc, char** argv) {
 		if(alib::XmlDataFactory::first<exception::AlibException>(tokens2)) std::cerr << alib::XmlDataFactory::fromTokens<exception::AlibException>(tokens2).getCause() << std::endl;
 		if(alib::XmlDataFactory::first<exception::AlibException>(tokens1) || alib::XmlDataFactory::first<exception::AlibException>(tokens2)) return 0;
 
-		if(alib::XmlDataFactory::first<automaton::Automaton>(tokens1) && alib::FromXMLParsers::automatonParser.first(tokens2)) {
+		if(alib::XmlDataFactory::first<automaton::Automaton>(tokens1) && alib::XmlDataFactory::first<automaton::Automaton>(tokens2)) {
 			automaton::Automaton automaton1 = alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens1);
 			automaton::Automaton automaton2 = alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens2);
 
 			return AutomatonCompare::compare(automaton1, automaton2);
 		}
 
-		if(alib::FromXMLParsers::grammarParser.first(tokens1) && alib::FromXMLParsers::grammarParser.first(tokens2)) {
+		if(alib::XmlDataFactory::first<grammar::Grammar>(tokens1) && alib::XmlDataFactory::first<grammar::Grammar>(tokens2)) {
 			grammar::Grammar grammar1 = alib::XmlDataFactory::fromTokens<grammar::Grammar>(tokens1);
 			grammar::Grammar grammar2 = alib::XmlDataFactory::fromTokens<grammar::Grammar>(tokens2);
 
diff --git a/alib2data/src/XmlApi.cpp b/alib2data/src/XmlApi.cpp
index 2598b4b38f..716ecdc511 100644
--- a/alib2data/src/XmlApi.cpp
+++ b/alib2data/src/XmlApi.cpp
@@ -115,11 +115,11 @@ const std::string Names::TREE_PREFIX_RANKED_BAR_PATTERN = "PrefixRankedBarPatter
 const std::string Names::TREE_UNRANKED_TREE = "UnrankedTree";
 const std::string Names::TREE_UNRANKED_PATTERN = "UnrankedPattern";
 
-Void xmlApi<Void>::parse(std::deque<sax::Token>& input) {
+Void xmlApi<Void>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::objectParser.parseVoid(input);
 }
 
-bool xmlApi<Void>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<Void>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALIB_VOID);
 }
 
@@ -127,11 +127,11 @@ void xmlApi<Void>::compose(std::deque<sax::Token>& output, const Void& data) {
 	ToXMLComposers::objectComposer.compose(output, data);
 }
 
-container::Container xmlApi<container::Container>::parse(std::deque<sax::Token>& input) {
+container::Container xmlApi<container::Container>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::containerParser.parseContainer(input);
 }
 
-bool xmlApi<container::Container>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<container::Container>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return FromXMLParsers::containerParser.first(input);
 }
 
@@ -139,11 +139,11 @@ void xmlApi<container::Container>::compose(std::deque<sax::Token>& output, const
 	ToXMLComposers::containerComposer.compose(output, data);
 }
 
-container::ObjectsSet xmlApi<container::ObjectsSet>::parse(std::deque<sax::Token>& input) {
+container::ObjectsSet xmlApi<container::ObjectsSet>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::containerParser.parseObjectsSet(input);
 }
 
-bool xmlApi<container::ObjectsSet>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<container::ObjectsSet>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::CONTAINER_OBJECTS_SET);
 }
 
@@ -151,11 +151,11 @@ void xmlApi<container::ObjectsSet>::compose(std::deque<sax::Token>& output, cons
 	ToXMLComposers::containerComposer.compose(output, data);
 }
 
-container::ObjectsVector xmlApi<container::ObjectsVector>::parse(std::deque<sax::Token>& input) {
+container::ObjectsVector xmlApi<container::ObjectsVector>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::containerParser.parseObjectsVector(input);
 }
 
-bool xmlApi<container::ObjectsVector>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<container::ObjectsVector>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::CONTAINER_OBJECTS_VECTOR);
 }
 
@@ -163,11 +163,11 @@ void xmlApi<container::ObjectsVector>::compose(std::deque<sax::Token>& output, c
 	ToXMLComposers::containerComposer.compose(output, data);
 }
 
-container::ObjectsPair xmlApi<container::ObjectsPair>::parse(std::deque<sax::Token>& input) {
+container::ObjectsPair xmlApi<container::ObjectsPair>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::containerParser.parseObjectsPair(input);
 }
 
-bool xmlApi<container::ObjectsPair>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<container::ObjectsPair>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::CONTAINER_OBJECTS_PAIR);
 }
 
@@ -175,11 +175,11 @@ void xmlApi<container::ObjectsPair>::compose(std::deque<sax::Token>& output, con
 	ToXMLComposers::containerComposer.compose(output, data);
 }
 
-container::ObjectsMap xmlApi<container::ObjectsMap>::parse(std::deque<sax::Token>& input) {
+container::ObjectsMap xmlApi<container::ObjectsMap>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::containerParser.parseObjectsMap(input);
 }
 
-bool xmlApi<container::ObjectsMap>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<container::ObjectsMap>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::CONTAINER_OBJECTS_MAP);
 }
 
@@ -187,11 +187,11 @@ void xmlApi<container::ObjectsMap>::compose(std::deque<sax::Token>& output, cons
 	ToXMLComposers::containerComposer.compose(output, data);
 }
 
-alib::Object xmlApi<alib::Object>::parse(std::deque<sax::Token>& input) {
+alib::Object xmlApi<alib::Object>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::objectParser.parseObject(input);
 }
 
-bool xmlApi<alib::Object>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<alib::Object>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return FromXMLParsers::objectParser.first(input);
 }
 
@@ -199,11 +199,11 @@ void xmlApi<alib::Object>::compose(std::deque<sax::Token>& output, const alib::O
 	ToXMLComposers::objectComposer.compose(output, data);
 }
 
-exception::AlibException xmlApi<exception::AlibException>::parse(std::deque<sax::Token>& input) {
+exception::AlibException xmlApi<exception::AlibException>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::exceptionParser.parseException(input);
 }
 
-bool xmlApi<exception::AlibException>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<exception::AlibException>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::EXCEPTION_ALIB_EXCEPTION);
 }
 
@@ -211,11 +211,11 @@ void xmlApi<exception::AlibException>::compose(std::deque<sax::Token>& output, c
 	ToXMLComposers::exceptionComposer.compose(output, data);
 }
 
-alphabet::Symbol xmlApi<alphabet::Symbol>::parse(std::deque<sax::Token>& input) {
+alphabet::Symbol xmlApi<alphabet::Symbol>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::symbolParser.parseSymbol(input);
 }
 
-bool xmlApi<alphabet::Symbol>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<alphabet::Symbol>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return FromXMLParsers::symbolParser.first(input);
 }
 
@@ -223,11 +223,11 @@ void xmlApi<alphabet::Symbol>::compose(std::deque<sax::Token>& output, const alp
 	ToXMLComposers::symbolComposer.compose(output, data);
 }
 
-alphabet::LabeledSymbol xmlApi<alphabet::LabeledSymbol>::parse(std::deque<sax::Token>& input) {
+alphabet::LabeledSymbol xmlApi<alphabet::LabeledSymbol>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::symbolParser.parseLabeledSymbol(input);
 }
 
-bool xmlApi<alphabet::LabeledSymbol>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<alphabet::LabeledSymbol>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALPHABET_LABELED_SYMBOL);
 }
 
@@ -235,11 +235,11 @@ void xmlApi<alphabet::LabeledSymbol>::compose(std::deque<sax::Token>& output, co
 	ToXMLComposers::symbolComposer.compose(output, data);
 }
 
-alphabet::BlankSymbol xmlApi<alphabet::BlankSymbol>::parse(std::deque<sax::Token>& input) {
+alphabet::BlankSymbol xmlApi<alphabet::BlankSymbol>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::symbolParser.parseBlankSymbol(input);
 }
 
-bool xmlApi<alphabet::BlankSymbol>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<alphabet::BlankSymbol>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALPHABET_BLANK_SYMBOL);
 }
 
@@ -247,11 +247,11 @@ void xmlApi<alphabet::BlankSymbol>::compose(std::deque<sax::Token>& output, cons
 	ToXMLComposers::symbolComposer.compose(output, data);
 }
 
-alphabet::BottomOfTheStackSymbol xmlApi<alphabet::BottomOfTheStackSymbol>::parse(std::deque<sax::Token>& input) {
+alphabet::BottomOfTheStackSymbol xmlApi<alphabet::BottomOfTheStackSymbol>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::symbolParser.parseBottomOfTheStackSymbol(input);
 }
 
-bool xmlApi<alphabet::BottomOfTheStackSymbol>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<alphabet::BottomOfTheStackSymbol>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALPHABET_BOTTOM_OF_THE_STACK_SYMBOL);
 }
 
@@ -259,11 +259,11 @@ void xmlApi<alphabet::BottomOfTheStackSymbol>::compose(std::deque<sax::Token>& o
 	ToXMLComposers::symbolComposer.compose(output, data);
 }
 
-alphabet::EndSymbol xmlApi<alphabet::EndSymbol>::parse(std::deque<sax::Token>& input) {
+alphabet::EndSymbol xmlApi<alphabet::EndSymbol>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::symbolParser.parseEndSymbol(input);
 }
 
-bool xmlApi<alphabet::EndSymbol>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<alphabet::EndSymbol>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALPHABET_END_SYMBOL);
 }
 
@@ -271,11 +271,11 @@ void xmlApi<alphabet::EndSymbol>::compose(std::deque<sax::Token>& output, const
 	ToXMLComposers::symbolComposer.compose(output, data);
 }
 
-alphabet::StartSymbol xmlApi<alphabet::StartSymbol>::parse(std::deque<sax::Token>& input) {
+alphabet::StartSymbol xmlApi<alphabet::StartSymbol>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::symbolParser.parseStartSymbol(input);
 }
 
-bool xmlApi<alphabet::StartSymbol>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<alphabet::StartSymbol>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALPHABET_START_SYMBOL);
 }
 
@@ -283,11 +283,11 @@ void xmlApi<alphabet::StartSymbol>::compose(std::deque<sax::Token>& output, cons
 	ToXMLComposers::symbolComposer.compose(output, data);
 }
 
-alphabet::RankedSymbol xmlApi<alphabet::RankedSymbol>::parse(std::deque<sax::Token>& input) {
+alphabet::RankedSymbol xmlApi<alphabet::RankedSymbol>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::symbolParser.parseRankedSymbol(input);
 }
 
-bool xmlApi<alphabet::RankedSymbol>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<alphabet::RankedSymbol>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALPHABET_RANKED_SYMBOL);
 }
 
@@ -295,11 +295,11 @@ void xmlApi<alphabet::RankedSymbol>::compose(std::deque<sax::Token>& output, con
 	ToXMLComposers::symbolComposer.compose(output, data);
 }
 
-alphabet::BarSymbol xmlApi<alphabet::BarSymbol>::parse(std::deque<sax::Token>& input) {
+alphabet::BarSymbol xmlApi<alphabet::BarSymbol>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::symbolParser.parseBarSymbol(input);
 }
 
-bool xmlApi<alphabet::BarSymbol>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<alphabet::BarSymbol>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALPHABET_BAR_SYMBOL);
 }
 
@@ -307,11 +307,11 @@ void xmlApi<alphabet::BarSymbol>::compose(std::deque<sax::Token>& output, const
 	ToXMLComposers::symbolComposer.compose(output, data);
 }
 
-alphabet::VariablesBarSymbol xmlApi<alphabet::VariablesBarSymbol>::parse(std::deque<sax::Token>& input) {
+alphabet::VariablesBarSymbol xmlApi<alphabet::VariablesBarSymbol>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::symbolParser.parseVariablesBarSymbol(input);
 }
 
-bool xmlApi<alphabet::VariablesBarSymbol>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<alphabet::VariablesBarSymbol>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALPHABET_VARIABLES_BAR_SYMBOL);
 }
 
@@ -319,11 +319,11 @@ void xmlApi<alphabet::VariablesBarSymbol>::compose(std::deque<sax::Token>& outpu
 	ToXMLComposers::symbolComposer.compose(output, data);
 }
 
-alphabet::SubtreeWildcardSymbol xmlApi<alphabet::SubtreeWildcardSymbol>::parse(std::deque<sax::Token>& input) {
+alphabet::SubtreeWildcardSymbol xmlApi<alphabet::SubtreeWildcardSymbol>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::symbolParser.parseSubtreeWildcardSymbol(input);
 }
 
-bool xmlApi<alphabet::SubtreeWildcardSymbol>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<alphabet::SubtreeWildcardSymbol>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALPHABET_SUBTREE_WILDCARD_SYMBOL);
 }
 
@@ -331,11 +331,11 @@ void xmlApi<alphabet::SubtreeWildcardSymbol>::compose(std::deque<sax::Token>& ou
 	ToXMLComposers::symbolComposer.compose(output, data);
 }
 
-alphabet::SymbolSetSymbol xmlApi<alphabet::SymbolSetSymbol>::parse(std::deque<sax::Token>& input) {
+alphabet::SymbolSetSymbol xmlApi<alphabet::SymbolSetSymbol>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::symbolParser.parseSymbolSetSymbol(input);
 }
 
-bool xmlApi<alphabet::SymbolSetSymbol>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<alphabet::SymbolSetSymbol>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALPHABET_SYMBOL_SET_SYMBOL);
 }
 
@@ -343,11 +343,11 @@ void xmlApi<alphabet::SymbolSetSymbol>::compose(std::deque<sax::Token>& output,
 	ToXMLComposers::symbolComposer.compose(output, data);
 }
 
-alphabet::SymbolPairSymbol xmlApi<alphabet::SymbolPairSymbol>::parse(std::deque<sax::Token>& input) {
+alphabet::SymbolPairSymbol xmlApi<alphabet::SymbolPairSymbol>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::symbolParser.parseSymbolPairSymbol(input);
 }
 
-bool xmlApi<alphabet::SymbolPairSymbol>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<alphabet::SymbolPairSymbol>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALPHABET_SYMBOL_PAIR_SYMBOL);
 }
 
@@ -355,11 +355,11 @@ void xmlApi<alphabet::SymbolPairSymbol>::compose(std::deque<sax::Token>& output,
 	ToXMLComposers::symbolComposer.compose(output, data);
 }
 
-alphabet::UniqueSymbol xmlApi<alphabet::UniqueSymbol>::parse(std::deque<sax::Token>& input) {
+alphabet::UniqueSymbol xmlApi<alphabet::UniqueSymbol>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::symbolParser.parseUniqueSymbol(input);
 }
 
-bool xmlApi<alphabet::UniqueSymbol>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<alphabet::UniqueSymbol>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALPHABET_UNIQUE_SYMBOL);
 }
 
@@ -368,11 +368,11 @@ void xmlApi<alphabet::UniqueSymbol>::compose(std::deque<sax::Token>& output, con
 }
 
 
-automaton::Automaton xmlApi<automaton::Automaton>::parse(std::deque<sax::Token>& input) {
+automaton::Automaton xmlApi<automaton::Automaton>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::automatonParser.parseAutomaton(input);
 }
 
-bool xmlApi<automaton::Automaton>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<automaton::Automaton>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return FromXMLParsers::automatonParser.first(input);
 }
 
@@ -380,11 +380,11 @@ void xmlApi<automaton::Automaton>::compose(std::deque<sax::Token>& output, const
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::EpsilonNFA xmlApi<automaton::EpsilonNFA>::parse(std::deque<sax::Token>& input) {
+automaton::EpsilonNFA xmlApi<automaton::EpsilonNFA>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::automatonParser.parseEpsilonNFA(input);
 }
 
-bool xmlApi<automaton::EpsilonNFA>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<automaton::EpsilonNFA>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_EPSILON_NFA);
 }
 
@@ -392,11 +392,11 @@ void xmlApi<automaton::EpsilonNFA>::compose(std::deque<sax::Token>& output, cons
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::MultiInitialStateNFA xmlApi<automaton::MultiInitialStateNFA>::parse(std::deque<sax::Token>& input) {
+automaton::MultiInitialStateNFA xmlApi<automaton::MultiInitialStateNFA>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::automatonParser.parseMultiInitialStateNFA(input);
 }
 
-bool xmlApi<automaton::MultiInitialStateNFA>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<automaton::MultiInitialStateNFA>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_MULTI_INITIAL_STATE_NFA);
 }
 
@@ -404,11 +404,11 @@ void xmlApi<automaton::MultiInitialStateNFA>::compose(std::deque<sax::Token>& ou
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::NFA xmlApi<automaton::NFA>::parse(std::deque<sax::Token>& input) {
+automaton::NFA xmlApi<automaton::NFA>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::automatonParser.parseNFA(input);
 }
 
-bool xmlApi<automaton::NFA>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<automaton::NFA>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_NFA);
 }
 
@@ -416,11 +416,11 @@ void xmlApi<automaton::NFA>::compose(std::deque<sax::Token>& output, const autom
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::DFA xmlApi<automaton::DFA>::parse(std::deque<sax::Token>& input) {
+automaton::DFA xmlApi<automaton::DFA>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::automatonParser.parseDFA(input);
 }
 
-bool xmlApi<automaton::DFA>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<automaton::DFA>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_DFA);
 }
 
@@ -428,11 +428,11 @@ void xmlApi<automaton::DFA>::compose(std::deque<sax::Token>& output, const autom
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::ExtendedNFA xmlApi<automaton::ExtendedNFA>::parse(std::deque<sax::Token>& input) {
+automaton::ExtendedNFA xmlApi<automaton::ExtendedNFA>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::automatonParser.parseExtendedNFA(input);
 }
 
-bool xmlApi<automaton::ExtendedNFA>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<automaton::ExtendedNFA>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_EXTENDED_NFA);
 }
 
@@ -440,11 +440,11 @@ void xmlApi<automaton::ExtendedNFA>::compose(std::deque<sax::Token>& output, con
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::CompactNFA xmlApi<automaton::CompactNFA>::parse(std::deque<sax::Token>& input) {
+automaton::CompactNFA xmlApi<automaton::CompactNFA>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::automatonParser.parseCompactNFA(input);
 }
 
-bool xmlApi<automaton::CompactNFA>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<automaton::CompactNFA>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_COMPACT_NFA);
 }
 
@@ -452,11 +452,11 @@ void xmlApi<automaton::CompactNFA>::compose(std::deque<sax::Token>& output, cons
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::DPDA xmlApi<automaton::DPDA>::parse(std::deque<sax::Token>& input) {
+automaton::DPDA xmlApi<automaton::DPDA>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::automatonParser.parseDPDA(input);
 }
 
-bool xmlApi<automaton::DPDA>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<automaton::DPDA>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_DPDA);
 }
 
@@ -464,11 +464,11 @@ void xmlApi<automaton::DPDA>::compose(std::deque<sax::Token>& output, const auto
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::SinglePopDPDA xmlApi<automaton::SinglePopDPDA>::parse(std::deque<sax::Token>& input) {
+automaton::SinglePopDPDA xmlApi<automaton::SinglePopDPDA>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::automatonParser.parseSinglePopDPDA(input);
 }
 
-bool xmlApi<automaton::SinglePopDPDA>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<automaton::SinglePopDPDA>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_SINGLE_POP_DPDA);
 }
 
@@ -476,11 +476,11 @@ void xmlApi<automaton::SinglePopDPDA>::compose(std::deque<sax::Token>& output, c
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::InputDrivenDPDA xmlApi<automaton::InputDrivenDPDA>::parse(std::deque<sax::Token>& input) {
+automaton::InputDrivenDPDA xmlApi<automaton::InputDrivenDPDA>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::automatonParser.parseInputDrivenDPDA(input);
 }
 
-bool xmlApi<automaton::InputDrivenDPDA>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<automaton::InputDrivenDPDA>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_INPUT_DRIVEN_DPDA);
 }
 
@@ -488,11 +488,11 @@ void xmlApi<automaton::InputDrivenDPDA>::compose(std::deque<sax::Token>& output,
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::InputDrivenNPDA xmlApi<automaton::InputDrivenNPDA>::parse(std::deque<sax::Token>& input) {
+automaton::InputDrivenNPDA xmlApi<automaton::InputDrivenNPDA>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::automatonParser.parseInputDrivenNPDA(input);
 }
 
-bool xmlApi<automaton::InputDrivenNPDA>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<automaton::InputDrivenNPDA>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_INPUT_DRIVEN_NPDA);
 }
 
@@ -500,11 +500,11 @@ void xmlApi<automaton::InputDrivenNPDA>::compose(std::deque<sax::Token>& output,
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::VisiblyPushdownDPDA xmlApi<automaton::VisiblyPushdownDPDA>::parse(std::deque<sax::Token>& input) {
+automaton::VisiblyPushdownDPDA xmlApi<automaton::VisiblyPushdownDPDA>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::automatonParser.parseVisiblyPushdownDPDA(input);
 }
 
-bool xmlApi<automaton::VisiblyPushdownDPDA>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<automaton::VisiblyPushdownDPDA>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_VISIBLY_PUSHDOWN_DPDA);
 }
 
@@ -512,11 +512,11 @@ void xmlApi<automaton::VisiblyPushdownDPDA>::compose(std::deque<sax::Token>& out
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::VisiblyPushdownNPDA xmlApi<automaton::VisiblyPushdownNPDA>::parse(std::deque<sax::Token>& input) {
+automaton::VisiblyPushdownNPDA xmlApi<automaton::VisiblyPushdownNPDA>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::automatonParser.parseVisiblyPushdownNPDA(input);
 }
 
-bool xmlApi<automaton::VisiblyPushdownNPDA>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<automaton::VisiblyPushdownNPDA>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_VISIBLY_PUSHDOWN_NPDA);
 }
 
@@ -524,11 +524,11 @@ void xmlApi<automaton::VisiblyPushdownNPDA>::compose(std::deque<sax::Token>& out
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::RealTimeHeightDeterministicDPDA xmlApi<automaton::RealTimeHeightDeterministicDPDA>::parse(std::deque<sax::Token>& input) {
+automaton::RealTimeHeightDeterministicDPDA xmlApi<automaton::RealTimeHeightDeterministicDPDA>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::automatonParser.parseRealTimeHeightDeterministicDPDA(input);
 }
 
-bool xmlApi<automaton::RealTimeHeightDeterministicDPDA>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<automaton::RealTimeHeightDeterministicDPDA>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_REAL_TIME_HEIGHT_DETERMINISTIC_DPDA);
 }
 
@@ -536,11 +536,11 @@ void xmlApi<automaton::RealTimeHeightDeterministicDPDA>::compose(std::deque<sax:
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::RealTimeHeightDeterministicNPDA xmlApi<automaton::RealTimeHeightDeterministicNPDA>::parse(std::deque<sax::Token>& input) {
+automaton::RealTimeHeightDeterministicNPDA xmlApi<automaton::RealTimeHeightDeterministicNPDA>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::automatonParser.parseRealTimeHeightDeterministicNPDA(input);
 }
 
-bool xmlApi<automaton::RealTimeHeightDeterministicNPDA>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<automaton::RealTimeHeightDeterministicNPDA>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_REAL_TIME_HEIGHT_DETERMINISTIC_NPDA);
 }
 
@@ -548,11 +548,11 @@ void xmlApi<automaton::RealTimeHeightDeterministicNPDA>::compose(std::deque<sax:
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::NPDA xmlApi<automaton::NPDA>::parse(std::deque<sax::Token>& input) {
+automaton::NPDA xmlApi<automaton::NPDA>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::automatonParser.parseNPDA(input);
 }
 
-bool xmlApi<automaton::NPDA>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<automaton::NPDA>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_NPDA);
 }
 
@@ -560,11 +560,11 @@ void xmlApi<automaton::NPDA>::compose(std::deque<sax::Token>& output, const auto
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::SinglePopNPDA xmlApi<automaton::SinglePopNPDA>::parse(std::deque<sax::Token>& input) {
+automaton::SinglePopNPDA xmlApi<automaton::SinglePopNPDA>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::automatonParser.parseSinglePopNPDA(input);
 }
 
-bool xmlApi<automaton::SinglePopNPDA>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<automaton::SinglePopNPDA>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_SINGLE_POP_NPDA);
 }
 
@@ -572,11 +572,11 @@ void xmlApi<automaton::SinglePopNPDA>::compose(std::deque<sax::Token>& output, c
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::OneTapeDTM xmlApi<automaton::OneTapeDTM>::parse(std::deque<sax::Token>& input) {
+automaton::OneTapeDTM xmlApi<automaton::OneTapeDTM>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::automatonParser.parseOneTapeDTM(input);
 }
 
-bool xmlApi<automaton::OneTapeDTM>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<automaton::OneTapeDTM>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_ONE_TAPE_DTM);
 }
 
@@ -584,11 +584,11 @@ void xmlApi<automaton::OneTapeDTM>::compose(std::deque<sax::Token>& output, cons
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::DFTA xmlApi<automaton::DFTA>::parse(std::deque<sax::Token>& input) {
+automaton::DFTA xmlApi<automaton::DFTA>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::automatonParser.parseDFTA(input);
 }
 
-bool xmlApi<automaton::DFTA>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<automaton::DFTA>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_DFTA);
 }
 
@@ -596,11 +596,11 @@ void xmlApi<automaton::DFTA>::compose(std::deque<sax::Token>& output, const auto
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::NFTA xmlApi<automaton::NFTA>::parse(std::deque<sax::Token>& input) {
+automaton::NFTA xmlApi<automaton::NFTA>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::automatonParser.parseNFTA(input);
 }
 
-bool xmlApi<automaton::NFTA>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<automaton::NFTA>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_NFTA);
 }
 
@@ -608,11 +608,11 @@ void xmlApi<automaton::NFTA>::compose(std::deque<sax::Token>& output, const auto
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::State xmlApi<automaton::State>::parse(std::deque<sax::Token>& input) {
+automaton::State xmlApi<automaton::State>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::automatonParser.parseState(input);
 }
 
-bool xmlApi<automaton::State>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<automaton::State>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_STATE);
 }
 
@@ -621,11 +621,11 @@ void xmlApi<automaton::State>::compose(std::deque<sax::Token>& output, const aut
 }
 
 
-grammar::Grammar xmlApi<grammar::Grammar>::parse(std::deque<sax::Token>& input) {
+grammar::Grammar xmlApi<grammar::Grammar>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::grammarParser.parseGrammar(input);
 }
 
-bool xmlApi<grammar::Grammar>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<grammar::Grammar>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return FromXMLParsers::grammarParser.first(input);
 }
 
@@ -633,11 +633,11 @@ void xmlApi<grammar::Grammar>::compose(std::deque<sax::Token>& output, const gra
 	ToXMLComposers::grammarComposer.compose(output, data);
 }
 
-grammar::LeftLG xmlApi<grammar::LeftLG>::parse(std::deque<sax::Token>& input) {
+grammar::LeftLG xmlApi<grammar::LeftLG>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::grammarParser.parseLeftLG(input);
 }
 
-bool xmlApi<grammar::LeftLG>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<grammar::LeftLG>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_LEFT_LG);
 }
 
@@ -645,11 +645,11 @@ void xmlApi<grammar::LeftLG>::compose(std::deque<sax::Token>& output, const gram
 	ToXMLComposers::grammarComposer.compose(output, data);
 }
 
-grammar::LeftRG xmlApi<grammar::LeftRG>::parse(std::deque<sax::Token>& input) {
+grammar::LeftRG xmlApi<grammar::LeftRG>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::grammarParser.parseLeftRG(input);
 }
 
-bool xmlApi<grammar::LeftRG>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<grammar::LeftRG>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_LEFT_RG);
 }
 
@@ -657,11 +657,11 @@ void xmlApi<grammar::LeftRG>::compose(std::deque<sax::Token>& output, const gram
 	ToXMLComposers::grammarComposer.compose(output, data);
 }
 
-grammar::RightLG xmlApi<grammar::RightLG>::parse(std::deque<sax::Token>& input) {
+grammar::RightLG xmlApi<grammar::RightLG>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::grammarParser.parseRightLG(input);
 }
 
-bool xmlApi<grammar::RightLG>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<grammar::RightLG>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_RIGHT_LG);
 }
 
@@ -669,11 +669,11 @@ void xmlApi<grammar::RightLG>::compose(std::deque<sax::Token>& output, const gra
 	ToXMLComposers::grammarComposer.compose(output, data);
 }
 
-grammar::RightRG xmlApi<grammar::RightRG>::parse(std::deque<sax::Token>& input) {
+grammar::RightRG xmlApi<grammar::RightRG>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::grammarParser.parseRightRG(input);
 }
 
-bool xmlApi<grammar::RightRG>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<grammar::RightRG>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_RIGHT_RG);
 }
 
@@ -681,11 +681,11 @@ void xmlApi<grammar::RightRG>::compose(std::deque<sax::Token>& output, const gra
 	ToXMLComposers::grammarComposer.compose(output, data);
 }
 
-grammar::LG xmlApi<grammar::LG>::parse(std::deque<sax::Token>& input) {
+grammar::LG xmlApi<grammar::LG>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::grammarParser.parseLG(input);
 }
 
-bool xmlApi<grammar::LG>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<grammar::LG>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_LG);
 }
 
@@ -693,11 +693,11 @@ void xmlApi<grammar::LG>::compose(std::deque<sax::Token>& output, const grammar:
 	ToXMLComposers::grammarComposer.compose(output, data);
 }
 
-grammar::CFG xmlApi<grammar::CFG>::parse(std::deque<sax::Token>& input) {
+grammar::CFG xmlApi<grammar::CFG>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::grammarParser.parseCFG(input);
 }
 
-bool xmlApi<grammar::CFG>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<grammar::CFG>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_CFG);
 }
 
@@ -705,11 +705,11 @@ void xmlApi<grammar::CFG>::compose(std::deque<sax::Token>& output, const grammar
 	ToXMLComposers::grammarComposer.compose(output, data);
 }
 
-grammar::EpsilonFreeCFG xmlApi<grammar::EpsilonFreeCFG>::parse(std::deque<sax::Token>& input) {
+grammar::EpsilonFreeCFG xmlApi<grammar::EpsilonFreeCFG>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::grammarParser.parseEpsilonFreeCFG(input);
 }
 
-bool xmlApi<grammar::EpsilonFreeCFG>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<grammar::EpsilonFreeCFG>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_EPSILON_FREE_CFG);
 }
 
@@ -717,11 +717,11 @@ void xmlApi<grammar::EpsilonFreeCFG>::compose(std::deque<sax::Token>& output, co
 	ToXMLComposers::grammarComposer.compose(output, data);
 }
 
-grammar::CNF xmlApi<grammar::CNF>::parse(std::deque<sax::Token>& input) {
+grammar::CNF xmlApi<grammar::CNF>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::grammarParser.parseCNF(input);
 }
 
-bool xmlApi<grammar::CNF>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<grammar::CNF>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_CNF);
 }
 
@@ -729,11 +729,11 @@ void xmlApi<grammar::CNF>::compose(std::deque<sax::Token>& output, const grammar
 	ToXMLComposers::grammarComposer.compose(output, data);
 }
 
-grammar::GNF xmlApi<grammar::GNF>::parse(std::deque<sax::Token>& input) {
+grammar::GNF xmlApi<grammar::GNF>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::grammarParser.parseGNF(input);
 }
 
-bool xmlApi<grammar::GNF>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<grammar::GNF>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_GNF);
 }
 
@@ -741,11 +741,11 @@ void xmlApi<grammar::GNF>::compose(std::deque<sax::Token>& output, const grammar
 	ToXMLComposers::grammarComposer.compose(output, data);
 }
 
-grammar::CSG xmlApi<grammar::CSG>::parse(std::deque<sax::Token>& input) {
+grammar::CSG xmlApi<grammar::CSG>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::grammarParser.parseCSG(input);
 }
 
-bool xmlApi<grammar::CSG>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<grammar::CSG>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_CSG);
 }
 
@@ -753,11 +753,11 @@ void xmlApi<grammar::CSG>::compose(std::deque<sax::Token>& output, const grammar
 	ToXMLComposers::grammarComposer.compose(output, data);
 }
 
-grammar::NonContractingGrammar xmlApi<grammar::NonContractingGrammar>::parse(std::deque<sax::Token>& input) {
+grammar::NonContractingGrammar xmlApi<grammar::NonContractingGrammar>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::grammarParser.parseNonContractingGrammar(input);
 }
 
-bool xmlApi<grammar::NonContractingGrammar>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<grammar::NonContractingGrammar>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_NON_CONTRACTING_GRAMMAR);
 }
 
@@ -765,11 +765,11 @@ void xmlApi<grammar::NonContractingGrammar>::compose(std::deque<sax::Token>& out
 	ToXMLComposers::grammarComposer.compose(output, data);
 }
 
-grammar::ContextPreservingUnrestrictedGrammar xmlApi<grammar::ContextPreservingUnrestrictedGrammar>::parse(std::deque<sax::Token>& input) {
+grammar::ContextPreservingUnrestrictedGrammar xmlApi<grammar::ContextPreservingUnrestrictedGrammar>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::grammarParser.parseContextPreservingUnrestrictedGrammar(input);
 }
 
-bool xmlApi<grammar::ContextPreservingUnrestrictedGrammar>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<grammar::ContextPreservingUnrestrictedGrammar>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_CONTEXT_PRESERVING_UNRESTRICTED_GRAMMAR);
 }
 
@@ -777,11 +777,11 @@ void xmlApi<grammar::ContextPreservingUnrestrictedGrammar>::compose(std::deque<s
 	ToXMLComposers::grammarComposer.compose(output, data);
 }
 
-grammar::UnrestrictedGrammar xmlApi<grammar::UnrestrictedGrammar>::parse(std::deque<sax::Token>& input) {
+grammar::UnrestrictedGrammar xmlApi<grammar::UnrestrictedGrammar>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::grammarParser.parseUnrestrictedGrammar(input);
 }
 
-bool xmlApi<grammar::UnrestrictedGrammar>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<grammar::UnrestrictedGrammar>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_UNRESTRICTED_GRAMMAR);
 }
 
@@ -790,11 +790,11 @@ void xmlApi<grammar::UnrestrictedGrammar>::compose(std::deque<sax::Token>& outpu
 }
 
 
-graph::Graph xmlApi<graph::Graph>::parse(std::deque<sax::Token>& input) {
+graph::Graph xmlApi<graph::Graph>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::graphParser.parseGraph(input);
 }
 
-bool xmlApi<graph::Graph>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<graph::Graph>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return FromXMLParsers::graphParser.first(input);
 }
 
@@ -802,11 +802,11 @@ void xmlApi<graph::Graph>::compose(std::deque<sax::Token>& output, const graph::
 	ToXMLComposers::graphComposer.compose(output, data);
 }
 
-graph::DirectedGraph xmlApi<graph::DirectedGraph>::parse(std::deque<sax::Token>& input) {
+graph::DirectedGraph xmlApi<graph::DirectedGraph>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::graphParser.parseDirectedGraph(input);
 }
 
-bool xmlApi<graph::DirectedGraph>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<graph::DirectedGraph>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAPH_DIRECTED_GRAPH);
 }
 
@@ -814,11 +814,11 @@ void xmlApi<graph::DirectedGraph>::compose(std::deque<sax::Token>& output, const
 	ToXMLComposers::graphComposer.compose(output, data);
 }
 
-graph::UndirectedGraph xmlApi<graph::UndirectedGraph>::parse(std::deque<sax::Token>& input) {
+graph::UndirectedGraph xmlApi<graph::UndirectedGraph>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::graphParser.parseUndirectedGraph(input);
 }
 
-bool xmlApi<graph::UndirectedGraph>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<graph::UndirectedGraph>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAPH_UNDIRECTED_GRAPH);
 }
 
@@ -827,11 +827,11 @@ void xmlApi<graph::UndirectedGraph>::compose(std::deque<sax::Token>& output, con
 }
 
 
-label::Label xmlApi<label::Label>::parse(std::deque<sax::Token>& input) {
+label::Label xmlApi<label::Label>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::labelParser.parseLabel(input);
 }
 
-bool xmlApi<label::Label>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<label::Label>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return FromXMLParsers::labelParser.first(input);
 }
 
@@ -839,11 +839,11 @@ void xmlApi<label::Label>::compose(std::deque<sax::Token>& output, const label::
 	ToXMLComposers::labelComposer.compose(output, data);
 }
 
-label::PrimitiveLabel xmlApi<label::PrimitiveLabel>::parse(std::deque<sax::Token>& input) {
+label::PrimitiveLabel xmlApi<label::PrimitiveLabel>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::labelParser.parsePrimitiveLabel(input);
 }
 
-bool xmlApi<label::PrimitiveLabel>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<label::PrimitiveLabel>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::LABEL_PRIMITIVE_LABEL);
 }
 
@@ -851,11 +851,11 @@ void xmlApi<label::PrimitiveLabel>::compose(std::deque<sax::Token>& output, cons
 	ToXMLComposers::labelComposer.compose(output, data);
 }
 
-label::HexavigesimalLabel xmlApi<label::HexavigesimalLabel>::parse(std::deque<sax::Token>& input) {
+label::HexavigesimalLabel xmlApi<label::HexavigesimalLabel>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::labelParser.parseHexavigesimalLabel(input);
 }
 
-bool xmlApi<label::HexavigesimalLabel>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<label::HexavigesimalLabel>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::LABEL_PRIMITIVE_LABEL);
 }
 
@@ -863,11 +863,11 @@ void xmlApi<label::HexavigesimalLabel>::compose(std::deque<sax::Token>& output,
 	ToXMLComposers::labelComposer.compose(output, data);
 }
 
-label::ObjectLabel xmlApi<label::ObjectLabel>::parse(std::deque<sax::Token>& input) {
+label::ObjectLabel xmlApi<label::ObjectLabel>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::labelParser.parseObjectLabel(input);
 }
 
-bool xmlApi<label::ObjectLabel>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<label::ObjectLabel>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::LABEL_OBJECT_LABEL);
 }
 
@@ -875,11 +875,11 @@ void xmlApi<label::ObjectLabel>::compose(std::deque<sax::Token>& output, const l
 	ToXMLComposers::labelComposer.compose(output, data);
 }
 
-label::LabelSetLabel xmlApi<label::LabelSetLabel>::parse(std::deque<sax::Token>& input) {
+label::LabelSetLabel xmlApi<label::LabelSetLabel>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::labelParser.parseLabelSetLabel(input);
 }
 
-bool xmlApi<label::LabelSetLabel>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<label::LabelSetLabel>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::LABEL_LABEL_SET_LABEL);
 }
 
@@ -887,11 +887,11 @@ void xmlApi<label::LabelSetLabel>::compose(std::deque<sax::Token>& output, const
 	ToXMLComposers::labelComposer.compose(output, data);
 }
 
-label::LabelPairLabel xmlApi<label::LabelPairLabel>::parse(std::deque<sax::Token>& input) {
+label::LabelPairLabel xmlApi<label::LabelPairLabel>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::labelParser.parseLabelPairLabel(input);
 }
 
-bool xmlApi<label::LabelPairLabel>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<label::LabelPairLabel>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::LABEL_LABEL_PAIR_LABEL);
 }
 
@@ -899,11 +899,11 @@ void xmlApi<label::LabelPairLabel>::compose(std::deque<sax::Token>& output, cons
 	ToXMLComposers::labelComposer.compose(output, data);
 }
 
-label::UniqueLabel xmlApi<label::UniqueLabel>::parse(std::deque<sax::Token>& input) {
+label::UniqueLabel xmlApi<label::UniqueLabel>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::labelParser.parseUniqueLabel(input);
 }
 
-bool xmlApi<label::UniqueLabel>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<label::UniqueLabel>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::LABEL_UNIQUE_LABEL);
 }
 
@@ -912,11 +912,11 @@ void xmlApi<label::UniqueLabel>::compose(std::deque<sax::Token>& output, const l
 }
 
 
-regexp::RegExp xmlApi<regexp::RegExp>::parse(std::deque<sax::Token>& input) {
+regexp::RegExp xmlApi<regexp::RegExp>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::regexpParser.parseRegExp(input);
 }
 
-bool xmlApi<regexp::RegExp>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<regexp::RegExp>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return FromXMLParsers::regexpParser.first(input);
 }
 
@@ -924,11 +924,11 @@ void xmlApi<regexp::RegExp>::compose(std::deque<sax::Token>& output, const regex
 	ToXMLComposers::regexpComposer.compose(output, data);
 }
 
-regexp::UnboundedRegExp xmlApi<regexp::UnboundedRegExp>::parse(std::deque<sax::Token>& input) {
+regexp::UnboundedRegExp xmlApi<regexp::UnboundedRegExp>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::regexpParser.parseUnboundedRegExp(input);
 }
 
-bool xmlApi<regexp::UnboundedRegExp>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<regexp::UnboundedRegExp>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::REGEXP_UNBOUNDED_REGEXP);
 }
 
@@ -936,11 +936,11 @@ void xmlApi<regexp::UnboundedRegExp>::compose(std::deque<sax::Token>& output, co
 	ToXMLComposers::regexpComposer.compose(output, data);
 }
 
-regexp::FormalRegExp xmlApi<regexp::FormalRegExp>::parse(std::deque<sax::Token>& input) {
+regexp::FormalRegExp xmlApi<regexp::FormalRegExp>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::regexpParser.parseFormalRegExp(input);
 }
 
-bool xmlApi<regexp::FormalRegExp>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<regexp::FormalRegExp>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::REGEXP_FORMAL_REGEXP);
 }
 
@@ -949,11 +949,11 @@ void xmlApi<regexp::FormalRegExp>::compose(std::deque<sax::Token>& output, const
 }
 
 
-string::String xmlApi<string::String>::parse(std::deque<sax::Token>& input) {
+string::String xmlApi<string::String>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::stringParser.parseString(input);
 }
 
-bool xmlApi<string::String>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<string::String>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return FromXMLParsers::stringParser.first(input);
 }
 
@@ -961,11 +961,11 @@ void xmlApi<string::String>::compose(std::deque<sax::Token>& output, const strin
 	ToXMLComposers::stringComposer.compose(output, data);
 }
 
-string::LinearString xmlApi<string::LinearString>::parse(std::deque<sax::Token>& input) {
+string::LinearString xmlApi<string::LinearString>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::stringParser.parseLinearString(input);
 }
 
-bool xmlApi<string::LinearString>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<string::LinearString>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::STRING_LINEAR_STRING);
 }
 
@@ -973,11 +973,11 @@ void xmlApi<string::LinearString>::compose(std::deque<sax::Token>& output, const
 	ToXMLComposers::stringComposer.compose(output, data);
 }
 
-string::CyclicString xmlApi<string::CyclicString>::parse(std::deque<sax::Token>& input) {
+string::CyclicString xmlApi<string::CyclicString>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::stringParser.parseCyclicString(input);
 }
 
-bool xmlApi<string::CyclicString>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<string::CyclicString>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::STRING_CYCLIC_STRING);
 }
 
@@ -985,11 +985,11 @@ void xmlApi<string::CyclicString>::compose(std::deque<sax::Token>& output, const
 	ToXMLComposers::stringComposer.compose(output, data);
 }
 
-string::Epsilon xmlApi<string::Epsilon>::parse(std::deque<sax::Token>& input) {
+string::Epsilon xmlApi<string::Epsilon>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::stringParser.parseEpsilon(input);
 }
 
-bool xmlApi<string::Epsilon>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<string::Epsilon>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::STRING_EPSILON);
 }
 
@@ -998,11 +998,11 @@ void xmlApi<string::Epsilon>::compose(std::deque<sax::Token>& output, const stri
 }
 
 
-primitive::Primitive xmlApi<primitive::Primitive>::parse(std::deque<sax::Token>& input) {
+primitive::Primitive xmlApi<primitive::Primitive>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::primitiveParser.parsePrimitive(input);
 }
 
-bool xmlApi<primitive::Primitive>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<primitive::Primitive>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return FromXMLParsers::primitiveParser.first(input);
 }
 
@@ -1010,11 +1010,11 @@ void xmlApi<primitive::Primitive>::compose(std::deque<sax::Token>& output, const
 	ToXMLComposers::primitiveComposer.compose(output, data);
 }
 
-primitive::String xmlApi<primitive::String>::parse(std::deque<sax::Token>& input) {
+primitive::String xmlApi<primitive::String>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::primitiveParser.parseString(input);
 }
 
-bool xmlApi<primitive::String>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<primitive::String>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_STRING);
 }
 
@@ -1022,11 +1022,11 @@ void xmlApi<primitive::String>::compose(std::deque<sax::Token>& output, const pr
 	ToXMLComposers::primitiveComposer.compose(output, data);
 }
 
-std::string xmlApi<std::string>::parse(std::deque<sax::Token>& input) {
+std::string xmlApi<std::string>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::primitiveParser.parseStringRaw(input);
 }
 
-bool xmlApi<std::string>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<std::string>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_STRING);
 }
 
@@ -1034,11 +1034,11 @@ void xmlApi<std::string>::compose(std::deque<sax::Token>& output, const std::str
 	ToXMLComposers::primitiveComposer.compose(output, data);
 }
 
-primitive::Integer xmlApi<primitive::Integer>::parse(std::deque<sax::Token>& input) {
+primitive::Integer xmlApi<primitive::Integer>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::primitiveParser.parseInteger(input);
 }
 
-bool xmlApi<primitive::Integer>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<primitive::Integer>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_INTEGER);
 }
 
@@ -1046,11 +1046,11 @@ void xmlApi<primitive::Integer>::compose(std::deque<sax::Token>& output, const p
 	ToXMLComposers::primitiveComposer.compose(output, data);
 }
 
-int xmlApi<int>::parse(std::deque<sax::Token>& input) {
+int xmlApi<int>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::primitiveParser.parseIntegerRaw(input);
 }
 
-bool xmlApi<int>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<int>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_INTEGER);
 }
 
@@ -1058,11 +1058,11 @@ void xmlApi<int>::compose(std::deque<sax::Token>& output, int data) {
 	ToXMLComposers::primitiveComposer.compose(output, data);
 }
 
-primitive::Character xmlApi<primitive::Character>::parse(std::deque<sax::Token>& input) {
+primitive::Character xmlApi<primitive::Character>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::primitiveParser.parseCharacter(input);
 }
 
-bool xmlApi<primitive::Character>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<primitive::Character>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_CHARACTER);
 }
 
@@ -1070,11 +1070,11 @@ void xmlApi<primitive::Character>::compose(std::deque<sax::Token>& output, const
 	ToXMLComposers::primitiveComposer.compose(output, data);
 }
 
-primitive::Unsigned xmlApi<primitive::Unsigned>::parse(std::deque<sax::Token>& input) {
+primitive::Unsigned xmlApi<primitive::Unsigned>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::primitiveParser.parseUnsigned(input);
 }
 
-bool xmlApi<primitive::Unsigned>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<primitive::Unsigned>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_UNSIGNED);
 }
 
@@ -1082,11 +1082,11 @@ void xmlApi<primitive::Unsigned>::compose(std::deque<sax::Token>& output, const
 	ToXMLComposers::primitiveComposer.compose(output, data);
 }
 
-primitive::Bool xmlApi<primitive::Bool>::parse(std::deque<sax::Token>& input) {
+primitive::Bool xmlApi<primitive::Bool>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::primitiveParser.parseBool(input);
 }
 
-bool xmlApi<primitive::Bool>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<primitive::Bool>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_BOOL);
 }
 
@@ -1094,11 +1094,11 @@ void xmlApi<primitive::Bool>::compose(std::deque<sax::Token>& output, const prim
 	ToXMLComposers::primitiveComposer.compose(output, data);
 }
 
-char xmlApi<char>::parse(std::deque<sax::Token>& input) {
+char xmlApi<char>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::primitiveParser.parseCharacterRaw(input);
 }
 
-bool xmlApi<char>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<char>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_CHARACTER);
 }
 
@@ -1106,11 +1106,11 @@ void xmlApi<char>::compose(std::deque<sax::Token>& output, char data) {
 	ToXMLComposers::primitiveComposer.compose(output, data);
 }
 
-unsigned xmlApi<unsigned>::parse(std::deque<sax::Token>& input) {
+unsigned xmlApi<unsigned>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::primitiveParser.parseCharacterRaw(input);
 }
 
-bool xmlApi<unsigned>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<unsigned>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_CHARACTER);
 }
 
@@ -1118,11 +1118,11 @@ void xmlApi<unsigned>::compose(std::deque<sax::Token>& output, unsigned data) {
 	ToXMLComposers::primitiveComposer.compose(output, data);
 }
 
-bool xmlApi<bool>::parse(std::deque<sax::Token>& input) {
+bool xmlApi<bool>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::primitiveParser.parseCharacterRaw(input);
 }
 
-bool xmlApi<bool>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<bool>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_CHARACTER);
 }
 
@@ -1130,11 +1130,11 @@ void xmlApi<bool>::compose(std::deque<sax::Token>& output, bool data) {
 	ToXMLComposers::primitiveComposer.compose(output, data);
 }
 
-tree::Tree xmlApi<tree::Tree>::parse(std::deque<sax::Token>& input) {
+tree::Tree xmlApi<tree::Tree>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::treeParser.parseTree(input);
 }
 
-bool xmlApi<tree::Tree>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<tree::Tree>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return FromXMLParsers::treeParser.first(input);
 }
 
@@ -1142,11 +1142,11 @@ void xmlApi<tree::Tree>::compose(std::deque<sax::Token>& output, const tree::Tre
 	ToXMLComposers::treeComposer.compose(output, data);
 }
 
-tree::PrefixRankedTree xmlApi<tree::PrefixRankedTree>::parse(std::deque<sax::Token>& input) {
+tree::PrefixRankedTree xmlApi<tree::PrefixRankedTree>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::treeParser.parsePrefixRankedTree(input);
 }
 
-bool xmlApi<tree::PrefixRankedTree>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<tree::PrefixRankedTree>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::TREE_PREFIX_RANKED_TREE);
 }
 
@@ -1154,11 +1154,11 @@ void xmlApi<tree::PrefixRankedTree>::compose(std::deque<sax::Token>& output, con
 	ToXMLComposers::treeComposer.compose(output, data);
 }
 
-tree::PrefixRankedBarTree xmlApi<tree::PrefixRankedBarTree>::parse(std::deque<sax::Token>& input) {
+tree::PrefixRankedBarTree xmlApi<tree::PrefixRankedBarTree>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::treeParser.parsePrefixRankedBarTree(input);
 }
 
-bool xmlApi<tree::PrefixRankedBarTree>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<tree::PrefixRankedBarTree>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::TREE_PREFIX_RANKED_BAR_TREE);
 }
 
@@ -1166,11 +1166,11 @@ void xmlApi<tree::PrefixRankedBarTree>::compose(std::deque<sax::Token>& output,
 	ToXMLComposers::treeComposer.compose(output, data);
 }
 
-tree::PrefixRankedPattern xmlApi<tree::PrefixRankedPattern>::parse(std::deque<sax::Token>& input) {
+tree::PrefixRankedPattern xmlApi<tree::PrefixRankedPattern>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::treeParser.parsePrefixRankedPattern(input);
 }
 
-bool xmlApi<tree::PrefixRankedPattern>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<tree::PrefixRankedPattern>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::TREE_PREFIX_RANKED_PATTERN);
 }
 
@@ -1178,11 +1178,11 @@ void xmlApi<tree::PrefixRankedPattern>::compose(std::deque<sax::Token>& output,
 	ToXMLComposers::treeComposer.compose(output, data);
 }
 
-tree::PrefixRankedBarPattern xmlApi<tree::PrefixRankedBarPattern>::parse(std::deque<sax::Token>& input) {
+tree::PrefixRankedBarPattern xmlApi<tree::PrefixRankedBarPattern>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::treeParser.parsePrefixRankedBarPattern(input);
 }
 
-bool xmlApi<tree::PrefixRankedBarPattern>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<tree::PrefixRankedBarPattern>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::TREE_PREFIX_RANKED_BAR_PATTERN);
 }
 
@@ -1190,11 +1190,11 @@ void xmlApi<tree::PrefixRankedBarPattern>::compose(std::deque<sax::Token>& outpu
 	ToXMLComposers::treeComposer.compose(output, data);
 }
 
-tree::RankedTree xmlApi<tree::RankedTree>::parse(std::deque<sax::Token>& input) {
+tree::RankedTree xmlApi<tree::RankedTree>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::treeParser.parseRankedTree(input);
 }
 
-bool xmlApi<tree::RankedTree>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<tree::RankedTree>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::TREE_RANKED_TREE);
 }
 
@@ -1202,11 +1202,11 @@ void xmlApi<tree::RankedTree>::compose(std::deque<sax::Token>& output, const tre
 	ToXMLComposers::treeComposer.compose(output, data);
 }
 
-tree::RankedPattern xmlApi<tree::RankedPattern>::parse(std::deque<sax::Token>& input) {
+tree::RankedPattern xmlApi<tree::RankedPattern>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::treeParser.parseRankedPattern(input);
 }
 
-bool xmlApi<tree::RankedPattern>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<tree::RankedPattern>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::TREE_RANKED_PATTERN);
 }
 
@@ -1214,11 +1214,11 @@ void xmlApi<tree::RankedPattern>::compose(std::deque<sax::Token>& output, const
 	ToXMLComposers::treeComposer.compose(output, data);
 }
 
-tree::UnrankedTree xmlApi<tree::UnrankedTree>::parse(std::deque<sax::Token>& input) {
+tree::UnrankedTree xmlApi<tree::UnrankedTree>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::treeParser.parseUnrankedTree(input);
 }
 
-bool xmlApi<tree::UnrankedTree>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<tree::UnrankedTree>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::TREE_UNRANKED_TREE);
 }
 
@@ -1226,11 +1226,11 @@ void xmlApi<tree::UnrankedTree>::compose(std::deque<sax::Token>& output, const t
 	ToXMLComposers::treeComposer.compose(output, data);
 }
 
-tree::UnrankedPattern xmlApi<tree::UnrankedPattern>::parse(std::deque<sax::Token>& input) {
+tree::UnrankedPattern xmlApi<tree::UnrankedPattern>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::treeParser.parseUnrankedPattern(input);
 }
 
-bool xmlApi<tree::UnrankedPattern>::first(const std::deque<sax::Token>& input) {
+bool xmlApi<tree::UnrankedPattern>::first(const std::deque<sax::Token>::const_iterator& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::TREE_UNRANKED_PATTERN);
 }
 
diff --git a/alib2data/src/XmlApi.hpp b/alib2data/src/XmlApi.hpp
index e2f1fdefda..9adec26a85 100644
--- a/alib2data/src/XmlApi.hpp
+++ b/alib2data/src/XmlApi.hpp
@@ -120,79 +120,79 @@ public:
 
 template<typename T>
 struct xmlApi {
-	static T parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static T parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const T& data);
 };
 
 template<>
 struct xmlApi<Void> {
-	static Void parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static Void parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const Void& data);
 };
 
 template<typename T>
 struct xmlApi<std::set<T>> {
-	static std::set<T> parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static std::set<T> parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const std::set<T>& data);
 };
 
 template<>
 struct xmlApi<container::ObjectsSet> {
-	static container::ObjectsSet parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static container::ObjectsSet parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const container::ObjectsSet& data);
 };
 
 template<typename T>
 struct xmlApi<std::vector<T>> {
-	static std::vector<T> parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static std::vector<T> parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const std::vector<T>& data);
 };
 
 template<>
 struct xmlApi<container::ObjectsVector> {
-	static container::ObjectsVector parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static container::ObjectsVector parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const container::ObjectsVector& data);
 };
 
 template<typename T, typename R>
 struct xmlApi<std::pair<T, R>> {
-	static std::pair<T, R> parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static std::pair<T, R> parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const std::pair<T, R>& data);
 };
 
 template<>
 struct xmlApi<container::ObjectsPair> {
-	static container::ObjectsPair parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static container::ObjectsPair parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const container::ObjectsPair& data);
 };
 
 template<typename T, typename R>
 struct xmlApi<std::map<T, R>> {
-	static std::map<T, R> parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static std::map<T, R> parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const std::map<T, R>& data);
 };
 
 template<>
 struct xmlApi<container::ObjectsMap> {
-	static container::ObjectsMap parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static container::ObjectsMap parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const container::ObjectsMap& data);
 };
 
 /* TODO for gcc-4.9 uncomment
 template<typename ... Ts>
 struct xmlApi<std::variant<Ts...>> {
-	static std::variant<Ts...> parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static std::variant<Ts...> parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const std::variant<Ts...>& data);
 };
 
@@ -203,618 +203,618 @@ TODO tuple
 
 template<>
 struct xmlApi<Object> {
-	static Object parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static Object parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const Object& data);
 };
 
 
 template<>
 struct xmlApi<exception::AlibException> {
-	static exception::AlibException parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static exception::AlibException parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const exception::AlibException& data);
 };
 
 
 template<>
 struct xmlApi<alphabet::Symbol> {
-	static alphabet::Symbol parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static alphabet::Symbol parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const alphabet::Symbol& data);
 };
 
 template<>
 struct xmlApi<alphabet::LabeledSymbol> {
-	static alphabet::LabeledSymbol parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static alphabet::LabeledSymbol parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const alphabet::LabeledSymbol& data);
 };
 
 template<>
 struct xmlApi<alphabet::BlankSymbol> {
-	static alphabet::BlankSymbol parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static alphabet::BlankSymbol parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const alphabet::BlankSymbol& data);
 };
 
 template<>
 struct xmlApi<alphabet::BottomOfTheStackSymbol> {
-	static alphabet::BottomOfTheStackSymbol parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static alphabet::BottomOfTheStackSymbol parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const alphabet::BottomOfTheStackSymbol& data);
 };
 
 template<>
 struct xmlApi<alphabet::EndSymbol> {
-	static alphabet::EndSymbol parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static alphabet::EndSymbol parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const alphabet::EndSymbol& data);
 };
 
 template<>
 struct xmlApi<alphabet::StartSymbol> {
-	static alphabet::StartSymbol parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static alphabet::StartSymbol parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const alphabet::StartSymbol& data);
 };
 
 template<>
 struct xmlApi<alphabet::RankedSymbol> {
-	static alphabet::RankedSymbol parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static alphabet::RankedSymbol parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const alphabet::RankedSymbol& data);
 };
 
 template<>
 struct xmlApi<alphabet::BarSymbol> {
-	static alphabet::BarSymbol parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static alphabet::BarSymbol parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const alphabet::BarSymbol& data);
 };
 
 template<>
 struct xmlApi<alphabet::VariablesBarSymbol> {
-	static alphabet::VariablesBarSymbol parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static alphabet::VariablesBarSymbol parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const alphabet::VariablesBarSymbol& data);
 };
 
 template<>
 struct xmlApi<alphabet::SubtreeWildcardSymbol> {
-	static alphabet::SubtreeWildcardSymbol parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static alphabet::SubtreeWildcardSymbol parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const alphabet::SubtreeWildcardSymbol& data);
 };
 
 template<>
 struct xmlApi<alphabet::SymbolSetSymbol> {
-	static alphabet::SymbolSetSymbol parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static alphabet::SymbolSetSymbol parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const alphabet::SymbolSetSymbol& data);
 };
 
 template<>
 struct xmlApi<alphabet::SymbolPairSymbol> {
-	static alphabet::SymbolPairSymbol parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static alphabet::SymbolPairSymbol parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const alphabet::SymbolPairSymbol& data);
 };
 
 template<>
 struct xmlApi<alphabet::UniqueSymbol> {
-	static alphabet::UniqueSymbol parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static alphabet::UniqueSymbol parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const alphabet::UniqueSymbol& data);
 };
 
 
 template<>
 struct xmlApi<automaton::Automaton> {
-	static automaton::Automaton parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static automaton::Automaton parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const automaton::Automaton& data);
 };
 
 template<>
 struct xmlApi<automaton::EpsilonNFA> {
-	static automaton::EpsilonNFA parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static automaton::EpsilonNFA parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const automaton::EpsilonNFA& data);
 };
 
 template<>
 struct xmlApi<automaton::MultiInitialStateNFA> {
-	static automaton::MultiInitialStateNFA parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static automaton::MultiInitialStateNFA parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const automaton::MultiInitialStateNFA& data);
 };
 
 template<>
 struct xmlApi<automaton::NFA> {
-	static automaton::NFA parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static automaton::NFA parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const automaton::NFA& data);
 };
 
 template<>
 struct xmlApi<automaton::DFA> {
-	static automaton::DFA parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static automaton::DFA parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const automaton::DFA& data);
 };
 
 template<>
 struct xmlApi<automaton::ExtendedNFA> {
-	static automaton::ExtendedNFA parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static automaton::ExtendedNFA parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const automaton::ExtendedNFA& data);
 };
 
 template<>
 struct xmlApi<automaton::CompactNFA> {
-	static automaton::CompactNFA parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static automaton::CompactNFA parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const automaton::CompactNFA& data);
 };
 
 template<>
 struct xmlApi<automaton::DFTA> {
-	static automaton::DFTA parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static automaton::DFTA parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const automaton::DFTA& data);
 };
 
 template<>
 struct xmlApi<automaton::NFTA> {
-	static automaton::NFTA parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static automaton::NFTA parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const automaton::NFTA& data);
 };
 
 template<>
 struct xmlApi<automaton::DPDA> {
-	static automaton::DPDA parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static automaton::DPDA parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const automaton::DPDA& data);
 };
 
 template<>
 struct xmlApi<automaton::SinglePopDPDA> {
-	static automaton::SinglePopDPDA parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static automaton::SinglePopDPDA parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const automaton::SinglePopDPDA& data);
 };
 
 template<>
 struct xmlApi<automaton::InputDrivenDPDA> {
-	static automaton::InputDrivenDPDA parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static automaton::InputDrivenDPDA parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const automaton::InputDrivenDPDA& data);
 };
 
 template<>
 struct xmlApi<automaton::InputDrivenNPDA> {
-	static automaton::InputDrivenNPDA parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static automaton::InputDrivenNPDA parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const automaton::InputDrivenNPDA& data);
 };
 
 template<>
 struct xmlApi<automaton::VisiblyPushdownDPDA> {
-	static automaton::VisiblyPushdownDPDA parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static automaton::VisiblyPushdownDPDA parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const automaton::VisiblyPushdownDPDA& data);
 };
 
 template<>
 struct xmlApi<automaton::VisiblyPushdownNPDA> {
-	static automaton::VisiblyPushdownNPDA parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static automaton::VisiblyPushdownNPDA parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const automaton::VisiblyPushdownNPDA& data);
 };
 
 template<>
 struct xmlApi<automaton::RealTimeHeightDeterministicDPDA> {
-	static automaton::RealTimeHeightDeterministicDPDA parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static automaton::RealTimeHeightDeterministicDPDA parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const automaton::RealTimeHeightDeterministicDPDA& data);
 };
 
 template<>
 struct xmlApi<automaton::RealTimeHeightDeterministicNPDA> {
-	static automaton::RealTimeHeightDeterministicNPDA parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static automaton::RealTimeHeightDeterministicNPDA parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const automaton::RealTimeHeightDeterministicNPDA& data);
 };
 
 template<>
 struct xmlApi<automaton::NPDA> {
-	static automaton::NPDA parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static automaton::NPDA parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const automaton::NPDA& data);
 };
 
 template<>
 struct xmlApi<automaton::SinglePopNPDA> {
-	static automaton::SinglePopNPDA parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static automaton::SinglePopNPDA parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const automaton::SinglePopNPDA& data);
 };
 
 template<>
 struct xmlApi<automaton::OneTapeDTM> {
-	static automaton::OneTapeDTM parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static automaton::OneTapeDTM parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const automaton::OneTapeDTM& data);
 };
 
 template<>
 struct xmlApi<automaton::State> {
-	static automaton::State parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static automaton::State parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const automaton::State& data);
 };
 
 template<>
 struct xmlApi<grammar::Grammar> {
-	static grammar::Grammar parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static grammar::Grammar parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const grammar::Grammar& data);
 };
 
 template<>
 struct xmlApi<grammar::LeftLG> {
-	static grammar::LeftLG parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static grammar::LeftLG parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const grammar::LeftLG& data);
 };
 
 template<>
 struct xmlApi<grammar::LeftRG> {
-	static grammar::LeftRG parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static grammar::LeftRG parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const grammar::LeftRG& data);
 };
 
 template<>
 struct xmlApi<grammar::RightLG> {
-	static grammar::RightLG parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static grammar::RightLG parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const grammar::RightLG& data);
 };
 
 template<>
 struct xmlApi<grammar::RightRG> {
-	static grammar::RightRG parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static grammar::RightRG parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const grammar::RightRG& data);
 };
 
 template<>
 struct xmlApi<grammar::LG> {
-	static grammar::LG parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static grammar::LG parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const grammar::LG& data);
 };
 
 template<>
 struct xmlApi<grammar::CFG> {
-	static grammar::CFG parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static grammar::CFG parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const grammar::CFG& data);
 };
 
 template<>
 struct xmlApi<grammar::EpsilonFreeCFG> {
-	static grammar::EpsilonFreeCFG parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static grammar::EpsilonFreeCFG parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const grammar::EpsilonFreeCFG& data);
 };
 
 template<>
 struct xmlApi<grammar::CNF> {
-	static grammar::CNF parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static grammar::CNF parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const grammar::CNF& data);
 };
 
 template<>
 struct xmlApi<grammar::GNF> {
-	static grammar::GNF parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static grammar::GNF parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const grammar::GNF& data);
 };
 
 template<>
 struct xmlApi<grammar::CSG> {
-	static grammar::CSG parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static grammar::CSG parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const grammar::CSG& data);
 };
 
 template<>
 struct xmlApi<grammar::NonContractingGrammar> {
-	static grammar::NonContractingGrammar parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static grammar::NonContractingGrammar parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const grammar::NonContractingGrammar& data);
 };
 
 template<>
 struct xmlApi<grammar::ContextPreservingUnrestrictedGrammar> {
-	static grammar::ContextPreservingUnrestrictedGrammar parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static grammar::ContextPreservingUnrestrictedGrammar parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const grammar::ContextPreservingUnrestrictedGrammar& data);
 };
 
 template<>
 struct xmlApi<grammar::UnrestrictedGrammar> {
-	static grammar::UnrestrictedGrammar parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static grammar::UnrestrictedGrammar parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const grammar::UnrestrictedGrammar& data);
 };
 
 
 template<>
 struct xmlApi<graph::Graph> {
-	static graph::Graph parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static graph::Graph parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const graph::Graph& data);
 };
 
 template<>
 struct xmlApi<graph::DirectedGraph> {
-	static graph::DirectedGraph parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static graph::DirectedGraph parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const graph::DirectedGraph& data);
 };
 
 template<>
 struct xmlApi<graph::UndirectedGraph> {
-	static graph::UndirectedGraph parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static graph::UndirectedGraph parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const graph::UndirectedGraph& data);
 };
 
 
 template<>
 struct xmlApi<label::Label> {
-	static label::Label parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static label::Label parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const label::Label& data);
 };
 
 template<>
 struct xmlApi<label::PrimitiveLabel> {
-	static label::PrimitiveLabel parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static label::PrimitiveLabel parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const label::PrimitiveLabel& data);
 };
 
 template<>
 struct xmlApi<label::HexavigesimalLabel> {
-	static label::HexavigesimalLabel parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static label::HexavigesimalLabel parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const label::HexavigesimalLabel& data);
 };
 
 template<>
 struct xmlApi<label::ObjectLabel> {
-	static label::ObjectLabel parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static label::ObjectLabel parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const label::ObjectLabel& data);
 };
 
 template<>
 struct xmlApi<label::LabelSetLabel> {
-	static label::LabelSetLabel parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static label::LabelSetLabel parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const label::LabelSetLabel& data);
 };
 
 template<>
 struct xmlApi<label::LabelPairLabel> {
-	static label::LabelPairLabel parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static label::LabelPairLabel parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const label::LabelPairLabel& data);
 };
 
 template<>
 struct xmlApi<label::UniqueLabel> {
-	static label::UniqueLabel parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static label::UniqueLabel parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const label::UniqueLabel& data);
 };
 
 
 template<>
 struct xmlApi<regexp::RegExp> {
-	static regexp::RegExp parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static regexp::RegExp parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const regexp::RegExp& data);
 };
 
 template<>
 struct xmlApi<regexp::UnboundedRegExp> {
-	static regexp::UnboundedRegExp parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static regexp::UnboundedRegExp parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const regexp::UnboundedRegExp& data);
 };
 
 template<>
 struct xmlApi<regexp::FormalRegExp> {
-	static regexp::FormalRegExp parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static regexp::FormalRegExp parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const regexp::FormalRegExp& data);
 };
 
 
 template<>
 struct xmlApi<string::String> {
-	static string::String parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static string::String parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const string::String& data);
 };
 
 template<>
 struct xmlApi<string::LinearString> {
-	static string::LinearString parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static string::LinearString parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const string::LinearString& data);
 };
 
 template<>
 struct xmlApi<string::CyclicString> {
-	static string::CyclicString parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static string::CyclicString parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const string::CyclicString& data);
 };
 
 template<>
 struct xmlApi<string::Epsilon> {
-	static string::Epsilon parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static string::Epsilon parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const string::Epsilon& data);
 };
 
 
 template<>
 struct xmlApi<primitive::Primitive> {
-	static primitive::Primitive parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static primitive::Primitive parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const primitive::Primitive& data);
 };
 
 template<>
 struct xmlApi<primitive::String> {
-	static primitive::String parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static primitive::String parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const primitive::String& data);
 };
 
 template<>
 struct xmlApi<std::string> {
-	static std::string parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static std::string parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const std::string& data);
 };
 
 template<>
 struct xmlApi<primitive::Integer> {
-	static primitive::Integer parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static primitive::Integer parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const primitive::Integer& data);
 };
 
 template<>
 struct xmlApi<int> {
-	static int parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static int parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, int data);
 };
 
 template<>
 struct xmlApi<primitive::Character> {
-	static primitive::Character parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static primitive::Character parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const primitive::Character& data);
 };
 
 template<>
 struct xmlApi<char> {
-	static char parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static char parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, char data);
 };
 
 template<>
 struct xmlApi<primitive::Unsigned> {
-	static primitive::Unsigned parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static primitive::Unsigned parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const primitive::Unsigned& data);
 };
 
 template<>
 struct xmlApi<unsigned> {
-	static unsigned parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static unsigned parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, unsigned data);
 };
 
 template<>
 struct xmlApi<primitive::Bool> {
-	static primitive::Bool parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static primitive::Bool parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const primitive::Bool& data);
 };
 
 template<>
 struct xmlApi<bool> {
-	static bool parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static bool parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, bool data);
 };
 
 template<>
 struct xmlApi<tree::Tree> {
-	static tree::Tree parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static tree::Tree parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const tree::Tree& data);
 };
 
 template<>
 struct xmlApi<tree::RankedTree> {
-	static tree::RankedTree parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static tree::RankedTree parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const tree::RankedTree& data);
 };
 
 template<>
 struct xmlApi<tree::RankedPattern> {
-	static tree::RankedPattern parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static tree::RankedPattern parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const tree::RankedPattern& data);
 };
 
 template<>
 struct xmlApi<tree::PrefixRankedTree> {
-	static tree::PrefixRankedTree parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static tree::PrefixRankedTree parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const tree::PrefixRankedTree& data);
 };
 
 template<>
 struct xmlApi<tree::PrefixRankedBarTree> {
-	static tree::PrefixRankedBarTree parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static tree::PrefixRankedBarTree parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const tree::PrefixRankedBarTree& data);
 };
 
 template<>
 struct xmlApi<tree::PrefixRankedPattern> {
-	static tree::PrefixRankedPattern parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static tree::PrefixRankedPattern parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const tree::PrefixRankedPattern& data);
 };
 
 template<>
 struct xmlApi<tree::PrefixRankedBarPattern> {
-	static tree::PrefixRankedBarPattern parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static tree::PrefixRankedBarPattern parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const tree::PrefixRankedBarPattern& data);
 };
 
 template<>
 struct xmlApi<tree::UnrankedTree> {
-	static tree::UnrankedTree parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static tree::UnrankedTree parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const tree::UnrankedTree& data);
 };
 
 template<>
 struct xmlApi<tree::UnrankedPattern> {
-	static tree::UnrankedPattern parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static tree::UnrankedPattern parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const tree::UnrankedPattern& data);
 };
 
@@ -828,8 +828,8 @@ namespace alib {
 
 template<>
 struct xmlApi<container::Container> {
-	static container::Container parse(std::deque<sax::Token>& input);
-	static bool first(const std::deque<sax::Token>& input);
+	static container::Container parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
 	static void compose(std::deque<sax::Token>& output, const container::Container& data);
 };
 
@@ -965,13 +965,13 @@ public:
 };
 
 template<typename T>
-std::set<T> xmlApi<std::set<T>>::parse(std::deque<sax::Token>& input) {
+std::set<T> xmlApi<std::set<T>>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::containerParser.parseSet<T>(input);
 }
 
 template<typename T>
-bool xmlApi<std::set<T>>::first(const std::deque<sax::Token>& input) {
-	return input.front().getType() == sax::Token::TokenType::START_ELEMENT && input.front().getData() == Names::CONTAINER_OBJECTS_SET;
+bool xmlApi<std::set<T>>::first(const std::deque<sax::Token>::const_iterator& input) {
+	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::CONTAINER_OBJECTS_SET);
 }
 
 template<typename T>
@@ -980,13 +980,13 @@ void xmlApi<std::set<T>>::compose(std::deque<sax::Token>& output, const std::set
 }
 
 template<typename T>
-std::vector<T> xmlApi<std::vector<T>>::parse(std::deque<sax::Token>& input) {
+std::vector<T> xmlApi<std::vector<T>>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::containerParser.parseVector<T>(input);
 }
 
 template<typename T>
-bool xmlApi<std::vector<T>>::first(const std::deque<sax::Token>& input) {
-	return input.front().getType() == sax::Token::TokenType::START_ELEMENT && input.front().getData() == Names::CONTAINER_OBJECTS_VECTOR;
+bool xmlApi<std::vector<T>>::first(const std::deque<sax::Token>::const_iterator& input) {
+	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::CONTAINER_OBJECTS_VECTOR);
 }
 
 template<typename T>
@@ -995,13 +995,13 @@ void xmlApi<std::vector<T>>::compose(std::deque<sax::Token>& output, const std::
 }
 
 template<typename T, typename R>
-std::pair<T, R> xmlApi<std::pair<T, R>>::parse(std::deque<sax::Token>& input) {
+std::pair<T, R> xmlApi<std::pair<T, R>>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::containerParser.parsePair<T, R>(input);
 }
 
 template<typename T, typename R>
-bool xmlApi<std::pair<T, R>>::first(const std::deque<sax::Token>& input) {
-	return input.front().getType() == sax::Token::TokenType::START_ELEMENT && input.front().getData() == Names::CONTAINER_OBJECTS_PAIR;
+bool xmlApi<std::pair<T, R>>::first(const std::deque<sax::Token>::const_iterator& input) {
+	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::CONTAINER_OBJECTS_PAIR);
 }
 
 template<typename T, typename R>
@@ -1010,13 +1010,13 @@ void xmlApi<std::pair<T, R>>::compose(std::deque<sax::Token>& output, const std:
 }
 
 template<typename T, typename R>
-std::map<T, R> xmlApi<std::map<T, R>>::parse(std::deque<sax::Token>& input) {
+std::map<T, R> xmlApi<std::map<T, R>>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::containerParser.parseMap<T, R>(input);
 }
 
 template<typename T, typename R>
-bool xmlApi<std::map<T, R>>::first(const std::deque<sax::Token>& input) {
-	return input.front().getType() == sax::Token::TokenType::START_ELEMENT && input.front().getData() == Names::CONTAINER_OBJECTS_MAP;
+bool xmlApi<std::map<T, R>>::first(const std::deque<sax::Token>::const_iterator& input) {
+	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::CONTAINER_OBJECTS_MAP);
 }
 
 template<typename T, typename R>
@@ -1026,13 +1026,13 @@ void xmlApi<std::map<T, R>>::compose(std::deque<sax::Token>& output, const std::
 
 /* TODO For gcc-4.9 uncomment
 template<typename ... Ts>
-std::variant<Ts...> xmlApi<std::variant<Ts...>>::parse(std::deque<sax::Token>& input) {
+std::variant<Ts...> xmlApi<std::variant<Ts...>>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::containerParser.parseVariant<Ts...>(input);
 }
 
 template<typename ... Ts>
-bool xmlApi<std::variant<Ts...>>::first(const std::deque<sax::Token>& input) {
-	return input.front().getType() == sax::Token::TokenType::START_ELEMENT && input.front().getData() == Names::CONTAINER_OBJECTS_VARIANT;
+bool xmlApi<std::variant<Ts...>>::first(const std::deque<sax::Token>::const_iterator& input) {
+	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::CONTAINER_OBJECTS_VARIANT);
 }
 
 template<typename ... Ts>
diff --git a/alib2data/src/alphabet/SymbolFromXMLParser.cpp b/alib2data/src/alphabet/SymbolFromXMLParser.cpp
index d29283081c..4fa0ce2579 100644
--- a/alib2data/src/alphabet/SymbolFromXMLParser.cpp
+++ b/alib2data/src/alphabet/SymbolFromXMLParser.cpp
@@ -14,11 +14,11 @@
 
 namespace alphabet {
 
-Symbol SymbolFromXMLParser::parseSymbol(std::deque<sax::Token>& input) const {
+Symbol SymbolFromXMLParser::parseSymbol(std::deque<sax::Token>::iterator& input) const {
 	return parseSymbol(input, std::set<FEATURES>({FEATURES::LABELED, FEATURES::BLANK, FEATURES::BOTTOM, FEATURES::END, FEATURES::RANKED, FEATURES::BAR, FEATURES::VARIABLES_BAR, FEATURES::SUBTREE_WILDCARD, FEATURES::SYMBOL_PAIR_SYMBOL, FEATURES::SYMBOL_SET_SYMBOL, FEATURES::UNIQUE_SYMBOL, FEATURES::START}));
 }
 
-Symbol SymbolFromXMLParser::parseSymbol(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const {
+Symbol SymbolFromXMLParser::parseSymbol(std::deque<sax::Token>::iterator& input, const std::set<FEATURES>& features) const {
 	if(alib::xmlApi<LabeledSymbol>::first(input)) {
 		if(!features.count(FEATURES::LABELED)) throw exception::AlibException();
 		return Symbol(parseLabeledSymbol(input));
@@ -56,11 +56,11 @@ Symbol SymbolFromXMLParser::parseSymbol(std::deque<sax::Token>& input, const std
 		if(!features.count(FEATURES::UNIQUE_SYMBOL)) throw exception::AlibException();
 		return Symbol(parseUniqueSymbol(input));
 	} else {
-		throw sax::ParserException(sax::Token("LabeledSymbol, BlankSymbol, BottomOfTheStackSymbol, EndSymbol, StartSymbol, RankedSymbol, BarSymbol, VariablesBar, SubtreeWildcardSymbol, SymbolPairSymbol, SymbolSetSymbol, UniqueSymbol", sax::Token::TokenType::START_ELEMENT), input.front());
+		throw sax::ParserException(sax::Token("LabeledSymbol, BlankSymbol, BottomOfTheStackSymbol, EndSymbol, StartSymbol, RankedSymbol, BarSymbol, VariablesBar, SubtreeWildcardSymbol, SymbolPairSymbol, SymbolSetSymbol, UniqueSymbol", sax::Token::TokenType::START_ELEMENT), *input);
 	}
 }
 
-bool SymbolFromXMLParser::first(const std::deque<sax::Token>& input) const {
+bool SymbolFromXMLParser::first(const std::deque<sax::Token>::const_iterator& input) const {
 	if(alib::xmlApi<LabeledSymbol>::first(input) || alib::xmlApi<BlankSymbol>::first(input) || alib::xmlApi<BottomOfTheStackSymbol>::first(input) || alib::xmlApi<EndSymbol>::first(input) || alib::xmlApi<StartSymbol>::first(input) || alib::xmlApi<RankedSymbol>::first(input) || alib::xmlApi<BarSymbol>::first(input) || alib::xmlApi<VariablesBarSymbol>::first(input) || alib::xmlApi<SubtreeWildcardSymbol>::first(input) || alib::xmlApi<SymbolPairSymbol>::first(input) || alib::xmlApi<SymbolSetSymbol>::first(input)) {
 		return true;
 	} else {
@@ -68,38 +68,38 @@ bool SymbolFromXMLParser::first(const std::deque<sax::Token>& input) const {
 	}
 }
 
-LabeledSymbol SymbolFromXMLParser::parseLabeledSymbol(std::deque<sax::Token>& input) const {
+LabeledSymbol SymbolFromXMLParser::parseLabeledSymbol(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALPHABET_LABELED_SYMBOL);
 	label::Label data = alib::xmlApi<label::Label>::parse(input);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_LABELED_SYMBOL);
 	return LabeledSymbol(std::move(data));
 }
 
-BlankSymbol SymbolFromXMLParser::parseBlankSymbol(std::deque<sax::Token>& input) const {
+BlankSymbol SymbolFromXMLParser::parseBlankSymbol(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALPHABET_BLANK_SYMBOL);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_BLANK_SYMBOL);
 	return BlankSymbol();
 }
 
-BottomOfTheStackSymbol SymbolFromXMLParser::parseBottomOfTheStackSymbol(std::deque<sax::Token>& input) const {
+BottomOfTheStackSymbol SymbolFromXMLParser::parseBottomOfTheStackSymbol(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALPHABET_BOTTOM_OF_THE_STACK_SYMBOL);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_BOTTOM_OF_THE_STACK_SYMBOL);
 	return BottomOfTheStackSymbol();
 }
 
-EndSymbol SymbolFromXMLParser::parseEndSymbol(std::deque<sax::Token>& input) const {
+EndSymbol SymbolFromXMLParser::parseEndSymbol(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALPHABET_END_SYMBOL);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_END_SYMBOL);
 	return EndSymbol();
 }
 
-StartSymbol SymbolFromXMLParser::parseStartSymbol(std::deque<sax::Token>& input) const {
+StartSymbol SymbolFromXMLParser::parseStartSymbol(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALPHABET_END_SYMBOL);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_END_SYMBOL);
 	return StartSymbol();
 }
 
-RankedSymbol SymbolFromXMLParser::parseRankedSymbol(std::deque<sax::Token>& input) const {
+RankedSymbol SymbolFromXMLParser::parseRankedSymbol(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALPHABET_RANKED_SYMBOL);
 	alphabet::Symbol data = alib::xmlApi<alphabet::Symbol>::parse(input);
 	primitive::Unsigned rank = alib::xmlApi<primitive::Unsigned>::parse(input);
@@ -107,25 +107,25 @@ RankedSymbol SymbolFromXMLParser::parseRankedSymbol(std::deque<sax::Token>& inpu
 	return RankedSymbol(std::move(data), std::move(rank));
 }
 
-BarSymbol SymbolFromXMLParser::parseBarSymbol(std::deque<sax::Token>& input) const {
+BarSymbol SymbolFromXMLParser::parseBarSymbol(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALPHABET_BAR_SYMBOL);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_BAR_SYMBOL);
 	return BarSymbol();
 }
 
-VariablesBarSymbol SymbolFromXMLParser::parseVariablesBarSymbol(std::deque<sax::Token>& input) const {
+VariablesBarSymbol SymbolFromXMLParser::parseVariablesBarSymbol(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALPHABET_VARIABLES_BAR_SYMBOL);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_VARIABLES_BAR_SYMBOL);
 	return VariablesBarSymbol();
 }
 
-SubtreeWildcardSymbol SymbolFromXMLParser::parseSubtreeWildcardSymbol(std::deque<sax::Token>& input) const {
+SubtreeWildcardSymbol SymbolFromXMLParser::parseSubtreeWildcardSymbol(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALPHABET_SUBTREE_WILDCARD_SYMBOL);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_SUBTREE_WILDCARD_SYMBOL);
 	return SubtreeWildcardSymbol();
 }
 
-SymbolSetSymbol SymbolFromXMLParser::parseSymbolSetSymbol(std::deque<sax::Token>& input) const {
+SymbolSetSymbol SymbolFromXMLParser::parseSymbolSetSymbol(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALPHABET_SYMBOL_SET_SYMBOL);
 	std::set<Symbol> labels;
 	while(isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -135,7 +135,7 @@ SymbolSetSymbol SymbolFromXMLParser::parseSymbolSetSymbol(std::deque<sax::Token>
 	return SymbolSetSymbol(std::move(labels));
 }
 
-SymbolPairSymbol SymbolFromXMLParser::parseSymbolPairSymbol(std::deque<sax::Token>& input) const {
+SymbolPairSymbol SymbolFromXMLParser::parseSymbolPairSymbol(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALPHABET_SYMBOL_PAIR_SYMBOL);
 
 	Symbol firstSymbol = parseSymbol(input);
@@ -145,7 +145,7 @@ SymbolPairSymbol SymbolFromXMLParser::parseSymbolPairSymbol(std::deque<sax::Toke
 	return SymbolPairSymbol(std::make_pair(std::move(firstSymbol), std::move(secondSymbol)));
 }
 
-UniqueSymbol SymbolFromXMLParser::parseUniqueSymbol(std::deque<sax::Token>& input) const {
+UniqueSymbol SymbolFromXMLParser::parseUniqueSymbol(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALPHABET_UNIQUE_SYMBOL);
 
 	Symbol firstSymbol = parseSymbol(input);
diff --git a/alib2data/src/alphabet/SymbolFromXMLParser.h b/alib2data/src/alphabet/SymbolFromXMLParser.h
index 2fce739895..f21c8da768 100644
--- a/alib2data/src/alphabet/SymbolFromXMLParser.h
+++ b/alib2data/src/alphabet/SymbolFromXMLParser.h
@@ -46,25 +46,25 @@ public:
 	SymbolFromXMLParser() {}
 
 private:
-	Symbol parseSymbol(std::deque<sax::Token>& input) const;
-	Symbol parseSymbol(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const;
+	Symbol parseSymbol(std::deque<sax::Token>::iterator& input) const;
+	Symbol parseSymbol(std::deque<sax::Token>::iterator& input, const std::set<FEATURES>& features) const;
 
-	LabeledSymbol parseLabeledSymbol(std::deque<sax::Token>& input) const;
-	BlankSymbol parseBlankSymbol(std::deque<sax::Token>& input) const;
-	BottomOfTheStackSymbol parseBottomOfTheStackSymbol(std::deque<sax::Token>& input) const;
-	EndSymbol parseEndSymbol(std::deque<sax::Token>& input) const;
-	StartSymbol parseStartSymbol(std::deque<sax::Token>& input) const;
-	RankedSymbol parseRankedSymbol(std::deque<sax::Token>& input) const;
-	BarSymbol parseBarSymbol(std::deque<sax::Token>& input) const;
-	VariablesBarSymbol parseVariablesBarSymbol(std::deque<sax::Token>& input) const;
-	SubtreeWildcardSymbol parseSubtreeWildcardSymbol(std::deque<sax::Token>& input) const;
-	SymbolPairSymbol parseSymbolPairSymbol(std::deque<sax::Token>& input) const;
-	SymbolSetSymbol parseSymbolSetSymbol(std::deque<sax::Token>& input) const;
-	UniqueSymbol parseUniqueSymbol(std::deque<sax::Token>& input) const;
+	LabeledSymbol parseLabeledSymbol(std::deque<sax::Token>::iterator& input) const;
+	BlankSymbol parseBlankSymbol(std::deque<sax::Token>::iterator& input) const;
+	BottomOfTheStackSymbol parseBottomOfTheStackSymbol(std::deque<sax::Token>::iterator& input) const;
+	EndSymbol parseEndSymbol(std::deque<sax::Token>::iterator& input) const;
+	StartSymbol parseStartSymbol(std::deque<sax::Token>::iterator& input) const;
+	RankedSymbol parseRankedSymbol(std::deque<sax::Token>::iterator& input) const;
+	BarSymbol parseBarSymbol(std::deque<sax::Token>::iterator& input) const;
+	VariablesBarSymbol parseVariablesBarSymbol(std::deque<sax::Token>::iterator& input) const;
+	SubtreeWildcardSymbol parseSubtreeWildcardSymbol(std::deque<sax::Token>::iterator& input) const;
+	SymbolPairSymbol parseSymbolPairSymbol(std::deque<sax::Token>::iterator& input) const;
+	SymbolSetSymbol parseSymbolSetSymbol(std::deque<sax::Token>::iterator& input) const;
+	UniqueSymbol parseUniqueSymbol(std::deque<sax::Token>::iterator& input) const;
 
 	template<typename T> friend struct alib::xmlApi;
 public:
-	bool first(const std::deque<sax::Token>& input) const;
+	bool first(const std::deque<sax::Token>::const_iterator& input) const;
 };
 
 } /* namespace alphabet */
diff --git a/alib2data/src/automaton/AutomatonFromXMLParser.cpp b/alib2data/src/automaton/AutomatonFromXMLParser.cpp
index 6112d695f1..1a00c83623 100644
--- a/alib2data/src/automaton/AutomatonFromXMLParser.cpp
+++ b/alib2data/src/automaton/AutomatonFromXMLParser.cpp
@@ -15,11 +15,11 @@
 
 namespace automaton {
 
-Automaton AutomatonFromXMLParser::parseAutomaton(std::deque<sax::Token> &input) const {
+Automaton AutomatonFromXMLParser::parseAutomaton(std::deque<sax::Token>::iterator& input) const {
 	return parseAutomaton(input, std::set<FEATURES>({FEATURES::EPSILON_NFA, FEATURES::MULTI_INITIAL_STATE_NFA, FEATURES::NFA, FEATURES::DFA, FEATURES::COMPACT_NFA, FEATURES::EXTENDED_NFA, FEATURES::DFTA, FEATURES::NFTA, FEATURES::DPDA, FEATURES::SINGLE_POP_DPDA, FEATURES::INPUT_DRIVEN_DPDA, FEATURES::INPUT_DRIVEN_NPDA, FEATURES::VISIBLY_PUSHDOWN_DPDA, FEATURES::VISIBLY_PUSHDOWN_NPDA, FEATURES::REAL_TIME_HEIGHT_DETERMINISTIC_DPDA,  FEATURES::REAL_TIME_HEIGHT_DETERMINISTIC_NPDA, FEATURES::NPDA, FEATURES::SINGLE_POP_NPDA, FEATURES::ONE_TAPE_DTM}));
 }
 
-Automaton AutomatonFromXMLParser::parseAutomaton(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const {
+Automaton AutomatonFromXMLParser::parseAutomaton(std::deque<sax::Token>::iterator& input, const std::set<FEATURES>& features) const {
 	if(alib::xmlApi<EpsilonNFA>::first(input)) {
 		if(!features.count(FEATURES::EPSILON_NFA)) throw exception::AlibException();
 		return Automaton(parseEpsilonNFA(input));
@@ -78,10 +78,10 @@ Automaton AutomatonFromXMLParser::parseAutomaton(std::deque<sax::Token>& input,
 		if(!features.count(FEATURES::NFTA)) throw exception::AlibException();
 		return Automaton(parseNFTA(input));
 	} else
-		throw sax::ParserException(sax::Token("Automaton / EpsilonNFA / NFA / DFA / CompactNFA / ExtendedNFA / DFTA / NFTA / DPDA / SinglePopDPDA / InputDrivenDPDA / InputDrivenNPDA / VisiblyPushdownDPDA / VisiblyPushdownNPDA / RealTimeHeightDeterministicDPDA / RealTimeHeightDeterministicNPDA / NPDA / SinglePopNPDA / OneTapeDTM", sax::Token::TokenType::START_ELEMENT), input.front());
+		throw sax::ParserException(sax::Token("Automaton / EpsilonNFA / NFA / DFA / CompactNFA / ExtendedNFA / DFTA / NFTA / DPDA / SinglePopDPDA / InputDrivenDPDA / InputDrivenNPDA / VisiblyPushdownDPDA / VisiblyPushdownNPDA / RealTimeHeightDeterministicDPDA / RealTimeHeightDeterministicNPDA / NPDA / SinglePopNPDA / OneTapeDTM", sax::Token::TokenType::START_ELEMENT), *input);
 }
 
-bool AutomatonFromXMLParser::first(const std::deque<sax::Token>& input) const {
+bool AutomatonFromXMLParser::first(const std::deque<sax::Token>::const_iterator& input) const {
 	if(alib::xmlApi<EpsilonNFA>::first(input) || alib::xmlApi<NFA>::first(input) || alib::xmlApi<DFA>::first(input) || alib::xmlApi<CompactNFA>::first(input) || alib::xmlApi<ExtendedNFA>::first(input) || alib::xmlApi<DFTA>::first(input) || alib::xmlApi<NFTA>::first(input) || alib::xmlApi<DPDA>::first(input) || alib::xmlApi<SinglePopDPDA>::first(input) || alib::xmlApi<InputDrivenDPDA>::first(input) || alib::xmlApi<InputDrivenNPDA>::first(input) || alib::xmlApi<VisiblyPushdownDPDA>::first(input)  || alib::xmlApi<VisiblyPushdownNPDA>::first(input) || alib::xmlApi<RealTimeHeightDeterministicDPDA>::first(input) || alib::xmlApi<RealTimeHeightDeterministicNPDA>::first(input) || alib::xmlApi<NPDA>::first(input) || alib::xmlApi<SinglePopNPDA>::first(input) || alib::xmlApi<OneTapeDTM>::first(input)) {
 		return true;
 	} else {
@@ -90,7 +90,7 @@ bool AutomatonFromXMLParser::first(const std::deque<sax::Token>& input) const {
 }
 
 template<class T>
-void AutomatonFromXMLParser::parseTransitions(std::deque<sax::Token> &input, T& automaton) const {
+void AutomatonFromXMLParser::parseTransitions(std::deque<sax::Token>::iterator& input, T& automaton) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "transitions");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
 		parseTransition(input, automaton);
@@ -98,7 +98,7 @@ void AutomatonFromXMLParser::parseTransitions(std::deque<sax::Token> &input, T&
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "transitions");
 }
 
-DFA AutomatonFromXMLParser::parseDFA(std::deque<sax::Token>& input) const {
+DFA AutomatonFromXMLParser::parseDFA(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_DFA);
 
 	std::set<State> states = parseStates(input);
@@ -117,7 +117,7 @@ DFA AutomatonFromXMLParser::parseDFA(std::deque<sax::Token>& input) const {
 	return automaton;
 }
 
-NFA AutomatonFromXMLParser::parseNFA(std::deque<sax::Token>& input) const {
+NFA AutomatonFromXMLParser::parseNFA(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_NFA);
 
 	std::set<State> states = parseStates(input);
@@ -136,7 +136,7 @@ NFA AutomatonFromXMLParser::parseNFA(std::deque<sax::Token>& input) const {
 	return automaton;
 }
 
-MultiInitialStateNFA AutomatonFromXMLParser::parseMultiInitialStateNFA(std::deque<sax::Token>& input) const {
+MultiInitialStateNFA AutomatonFromXMLParser::parseMultiInitialStateNFA(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_MULTI_INITIAL_STATE_NFA);
 
 	std::set<State> states = parseStates(input);
@@ -156,7 +156,7 @@ MultiInitialStateNFA AutomatonFromXMLParser::parseMultiInitialStateNFA(std::dequ
 	return automaton;
 }
 
-EpsilonNFA AutomatonFromXMLParser::parseEpsilonNFA(std::deque<sax::Token>& input) const {
+EpsilonNFA AutomatonFromXMLParser::parseEpsilonNFA(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_EPSILON_NFA);
 
 	std::set<State> states = parseStates(input);
@@ -175,7 +175,7 @@ EpsilonNFA AutomatonFromXMLParser::parseEpsilonNFA(std::deque<sax::Token>& input
 	return automaton;
 }
 
-CompactNFA AutomatonFromXMLParser::parseCompactNFA(std::deque<sax::Token>& input) const {
+CompactNFA AutomatonFromXMLParser::parseCompactNFA(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_COMPACT_NFA);
 
 	std::set<State> states = parseStates(input);
@@ -194,7 +194,7 @@ CompactNFA AutomatonFromXMLParser::parseCompactNFA(std::deque<sax::Token>& input
 	return automaton;
 }
 
-ExtendedNFA AutomatonFromXMLParser::parseExtendedNFA(std::deque<sax::Token>& input) const {
+ExtendedNFA AutomatonFromXMLParser::parseExtendedNFA(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_EXTENDED_NFA);
 
 	std::set<State> states = parseStates(input);
@@ -213,7 +213,7 @@ ExtendedNFA AutomatonFromXMLParser::parseExtendedNFA(std::deque<sax::Token>& inp
 	return automaton;
 }
 
-DPDA AutomatonFromXMLParser::parseDPDA(std::deque<sax::Token>& input) const {
+DPDA AutomatonFromXMLParser::parseDPDA(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_DPDA);
 
 	std::set<State> states = parseStates(input);
@@ -236,7 +236,7 @@ DPDA AutomatonFromXMLParser::parseDPDA(std::deque<sax::Token>& input) const {
 	return automaton;
 }
 
-SinglePopDPDA AutomatonFromXMLParser::parseSinglePopDPDA(std::deque<sax::Token>& input) const {
+SinglePopDPDA AutomatonFromXMLParser::parseSinglePopDPDA(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_SINGLE_POP_DPDA);
 
 	std::set<State> states = parseStates(input);
@@ -259,7 +259,7 @@ SinglePopDPDA AutomatonFromXMLParser::parseSinglePopDPDA(std::deque<sax::Token>&
 	return automaton;
 }
 
-InputDrivenDPDA AutomatonFromXMLParser::parseInputDrivenDPDA(std::deque<sax::Token>& input) const {
+InputDrivenDPDA AutomatonFromXMLParser::parseInputDrivenDPDA(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_INPUT_DRIVEN_DPDA);
 
 	std::set<State> states = parseStates(input);
@@ -283,7 +283,7 @@ InputDrivenDPDA AutomatonFromXMLParser::parseInputDrivenDPDA(std::deque<sax::Tok
 	return automaton;
 }
 
-InputDrivenNPDA AutomatonFromXMLParser::parseInputDrivenNPDA(std::deque<sax::Token>& input) const {
+InputDrivenNPDA AutomatonFromXMLParser::parseInputDrivenNPDA(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_INPUT_DRIVEN_NPDA);
 
 	std::set<State> states = parseStates(input);
@@ -307,7 +307,7 @@ InputDrivenNPDA AutomatonFromXMLParser::parseInputDrivenNPDA(std::deque<sax::Tok
 	return automaton;
 }
 
-VisiblyPushdownDPDA AutomatonFromXMLParser::parseVisiblyPushdownDPDA(std::deque<sax::Token>& input) const {
+VisiblyPushdownDPDA AutomatonFromXMLParser::parseVisiblyPushdownDPDA(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_VISIBLY_PUSHDOWN_DPDA);
 
 	std::set<State> states = parseStates(input);
@@ -334,7 +334,7 @@ VisiblyPushdownDPDA AutomatonFromXMLParser::parseVisiblyPushdownDPDA(std::deque<
 	return automaton;
 }
 
-VisiblyPushdownNPDA AutomatonFromXMLParser::parseVisiblyPushdownNPDA(std::deque<sax::Token>& input) const {
+VisiblyPushdownNPDA AutomatonFromXMLParser::parseVisiblyPushdownNPDA(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_VISIBLY_PUSHDOWN_NPDA);
 
 	std::set<State> states = parseStates(input);
@@ -362,7 +362,7 @@ VisiblyPushdownNPDA AutomatonFromXMLParser::parseVisiblyPushdownNPDA(std::deque<
 	return automaton;
 }
 
-RealTimeHeightDeterministicDPDA AutomatonFromXMLParser::parseRealTimeHeightDeterministicDPDA(std::deque<sax::Token>& input) const {
+RealTimeHeightDeterministicDPDA AutomatonFromXMLParser::parseRealTimeHeightDeterministicDPDA(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_REAL_TIME_HEIGHT_DETERMINISTIC_DPDA);
 
 	std::set<State> states = parseStates(input);
@@ -385,7 +385,7 @@ RealTimeHeightDeterministicDPDA AutomatonFromXMLParser::parseRealTimeHeightDeter
 	return automaton;
 }
 
-RealTimeHeightDeterministicNPDA AutomatonFromXMLParser::parseRealTimeHeightDeterministicNPDA(std::deque<sax::Token>& input) const {
+RealTimeHeightDeterministicNPDA AutomatonFromXMLParser::parseRealTimeHeightDeterministicNPDA(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_REAL_TIME_HEIGHT_DETERMINISTIC_NPDA);
 
 	std::set<State> states = parseStates(input);
@@ -409,7 +409,7 @@ RealTimeHeightDeterministicNPDA AutomatonFromXMLParser::parseRealTimeHeightDeter
 	return automaton;
 }
 
-NPDA AutomatonFromXMLParser::parseNPDA(std::deque<sax::Token>& input) const {
+NPDA AutomatonFromXMLParser::parseNPDA(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_NPDA);
 
 	std::set<State> states = parseStates(input);
@@ -432,7 +432,7 @@ NPDA AutomatonFromXMLParser::parseNPDA(std::deque<sax::Token>& input) const {
 	return automaton;
 }
 
-SinglePopNPDA AutomatonFromXMLParser::parseSinglePopNPDA(std::deque<sax::Token>& input) const {
+SinglePopNPDA AutomatonFromXMLParser::parseSinglePopNPDA(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_SINGLE_POP_NPDA);
 
 	std::set<State> states = parseStates(input);
@@ -455,7 +455,7 @@ SinglePopNPDA AutomatonFromXMLParser::parseSinglePopNPDA(std::deque<sax::Token>&
 	return automaton;
 }
 
-OneTapeDTM AutomatonFromXMLParser::parseOneTapeDTM(std::deque<sax::Token>& input) const {
+OneTapeDTM AutomatonFromXMLParser::parseOneTapeDTM(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_ONE_TAPE_DTM);
 
 	std::set<State> states = parseStates(input);
@@ -477,7 +477,7 @@ OneTapeDTM AutomatonFromXMLParser::parseOneTapeDTM(std::deque<sax::Token>& input
 	return automaton;
 }
 
-DFTA AutomatonFromXMLParser::parseDFTA(std::deque<sax::Token>& input) const {
+DFTA AutomatonFromXMLParser::parseDFTA(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_DFTA);
 
 	std::set<State> states = parseStates(input);
@@ -495,7 +495,7 @@ DFTA AutomatonFromXMLParser::parseDFTA(std::deque<sax::Token>& input) const {
 	return automaton;
 }
 
-NFTA AutomatonFromXMLParser::parseNFTA(std::deque<sax::Token>& input) const {
+NFTA AutomatonFromXMLParser::parseNFTA(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_NFTA);
 
 	std::set<State> states = parseStates(input);
@@ -513,7 +513,7 @@ NFTA AutomatonFromXMLParser::parseNFTA(std::deque<sax::Token>& input) const {
 	return automaton;
 }
 
-std::set<State> AutomatonFromXMLParser::parseStates(std::deque<sax::Token> &input) const {
+std::set<State> AutomatonFromXMLParser::parseStates(std::deque<sax::Token>::iterator& input) const {
 	std::set<State> states;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "states");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -523,11 +523,11 @@ std::set<State> AutomatonFromXMLParser::parseStates(std::deque<sax::Token> &inpu
 	return states;
 }
 
-State AutomatonFromXMLParser::parseState(std::deque<sax::Token> &input) const {
+State AutomatonFromXMLParser::parseState(std::deque<sax::Token>::iterator& input) const {
 	return State(alib::xmlApi<label::Label>::parse(input));
 }
 
-std::set<alphabet::Symbol> AutomatonFromXMLParser::parseCallInputAlphabet(std::deque<sax::Token> &input) const {
+std::set<alphabet::Symbol> AutomatonFromXMLParser::parseCallInputAlphabet(std::deque<sax::Token>::iterator& input) const {
 	std::set<alphabet::Symbol> inputSymbols;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "callInputAlphabet");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -537,7 +537,7 @@ std::set<alphabet::Symbol> AutomatonFromXMLParser::parseCallInputAlphabet(std::d
 	return inputSymbols;
 }
 
-std::set<alphabet::Symbol> AutomatonFromXMLParser::parseReturnInputAlphabet(std::deque<sax::Token> &input) const {
+std::set<alphabet::Symbol> AutomatonFromXMLParser::parseReturnInputAlphabet(std::deque<sax::Token>::iterator& input) const {
 	std::set<alphabet::Symbol> inputSymbols;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "returnInputAlphabet");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -547,7 +547,7 @@ std::set<alphabet::Symbol> AutomatonFromXMLParser::parseReturnInputAlphabet(std:
 	return inputSymbols;
 }
 
-std::set<alphabet::Symbol> AutomatonFromXMLParser::parseLocalInputAlphabet(std::deque<sax::Token> &input) const {
+std::set<alphabet::Symbol> AutomatonFromXMLParser::parseLocalInputAlphabet(std::deque<sax::Token>::iterator& input) const {
 	std::set<alphabet::Symbol> inputSymbols;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "localInputAlphabet");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -557,7 +557,7 @@ std::set<alphabet::Symbol> AutomatonFromXMLParser::parseLocalInputAlphabet(std::
 	return inputSymbols;
 }
 
-std::set<alphabet::Symbol> AutomatonFromXMLParser::parseInputAlphabet(std::deque<sax::Token> &input) const {
+std::set<alphabet::Symbol> AutomatonFromXMLParser::parseInputAlphabet(std::deque<sax::Token>::iterator& input) const {
 	std::set<alphabet::Symbol> inputSymbols;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "inputAlphabet");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -567,7 +567,7 @@ std::set<alphabet::Symbol> AutomatonFromXMLParser::parseInputAlphabet(std::deque
 	return inputSymbols;
 }
 
-std::set<alphabet::RankedSymbol> AutomatonFromXMLParser::parseRankedInputAlphabet(std::deque<sax::Token> &input) const {
+std::set<alphabet::RankedSymbol> AutomatonFromXMLParser::parseRankedInputAlphabet(std::deque<sax::Token>::iterator& input) const {
 	std::set<alphabet::RankedSymbol> inputSymbols;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "rankedInputAlphabet");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -577,14 +577,14 @@ std::set<alphabet::RankedSymbol> AutomatonFromXMLParser::parseRankedInputAlphabe
 	return inputSymbols;
 }
 
-State AutomatonFromXMLParser::parseInitialState(std::deque<sax::Token> &input) const {
+State AutomatonFromXMLParser::parseInitialState(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "initialState");
 	State state(alib::xmlApi<label::Label>::parse(input));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "initialState");
 	return state;
 }
 
-std::set<State> AutomatonFromXMLParser::parseInitialStates(std::deque<sax::Token> &input) const {
+std::set<State> AutomatonFromXMLParser::parseInitialStates(std::deque<sax::Token>::iterator& input) const {
 	std::set<State> initialStates;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "initialStates");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -594,7 +594,7 @@ std::set<State> AutomatonFromXMLParser::parseInitialStates(std::deque<sax::Token
 	return initialStates;
 }
 
-std::set<State> AutomatonFromXMLParser::parseFinalStates(std::deque<sax::Token> &input) const {
+std::set<State> AutomatonFromXMLParser::parseFinalStates(std::deque<sax::Token>::iterator& input) const {
 	std::set<State> finalStates;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "finalStates");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -604,7 +604,7 @@ std::set<State> AutomatonFromXMLParser::parseFinalStates(std::deque<sax::Token>
 	return finalStates;
 }
 
-std::set<alphabet::Symbol> AutomatonFromXMLParser::parseStackAlphabet(std::deque<sax::Token> &input) const {
+std::set<alphabet::Symbol> AutomatonFromXMLParser::parseStackAlphabet(std::deque<sax::Token>::iterator& input) const {
 	std::set<alphabet::Symbol> stackSymbols;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "stackAlphabet");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -614,7 +614,7 @@ std::set<alphabet::Symbol> AutomatonFromXMLParser::parseStackAlphabet(std::deque
 	return stackSymbols;
 }
 
-std::set<alphabet::Symbol> AutomatonFromXMLParser::parseInitialStackSymbols(std::deque<sax::Token> &input) const {
+std::set<alphabet::Symbol> AutomatonFromXMLParser::parseInitialStackSymbols(std::deque<sax::Token>::iterator& input) const {
 	std::set<alphabet::Symbol> initialSymbols;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "initialStackSymbols");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -624,14 +624,14 @@ std::set<alphabet::Symbol> AutomatonFromXMLParser::parseInitialStackSymbols(std:
 	return initialSymbols;
 }
 
-alphabet::Symbol AutomatonFromXMLParser::parseInitialStackSymbol(std::deque<sax::Token> &input) const {
+alphabet::Symbol AutomatonFromXMLParser::parseInitialStackSymbol(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "initialStackSymbol");
 	alphabet::Symbol initialSymbol(alib::xmlApi<alphabet::Symbol>::parse(input));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "initialStackSymbol");
 	return initialSymbol;
 }
 
-std::set<alphabet::Symbol> AutomatonFromXMLParser::parseTapeAlphabet(std::deque<sax::Token> &input) const {
+std::set<alphabet::Symbol> AutomatonFromXMLParser::parseTapeAlphabet(std::deque<sax::Token>::iterator& input) const {
 	std::set<alphabet::Symbol> tapeSymbols;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "tapeAlphabet");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -641,21 +641,21 @@ std::set<alphabet::Symbol> AutomatonFromXMLParser::parseTapeAlphabet(std::deque<
 	return tapeSymbols;
 }
 
-alphabet::Symbol AutomatonFromXMLParser::parseBlankSymbol(std::deque<sax::Token>& input) const {
+alphabet::Symbol AutomatonFromXMLParser::parseBlankSymbol(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "blankSymbol");
 	alphabet::Symbol blank(alib::xmlApi<alphabet::Symbol>::parse(input));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "blankSymbol");
 	return blank;
 }
 
-alphabet::Symbol AutomatonFromXMLParser::parseBottomOfTheStackSymbol(std::deque<sax::Token>& input) const {
+alphabet::Symbol AutomatonFromXMLParser::parseBottomOfTheStackSymbol(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "bottomOfTheStackSymbol");
 	alphabet::Symbol blank(alib::xmlApi<alphabet::Symbol>::parse(input));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "bottomOfTheStackSymbol");
 	return blank;
 }
 
-void AutomatonFromXMLParser::parseInputToPushdownStoreOperation(std::deque<sax::Token>& input, automaton::InputDrivenDPDA& automaton) const {
+void AutomatonFromXMLParser::parseInputToPushdownStoreOperation(std::deque<sax::Token>::iterator& input, automaton::InputDrivenDPDA& automaton) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "inputToPushdownStoreOperations");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
 		popToken(input, sax::Token::TokenType::START_ELEMENT, "operation");
@@ -672,7 +672,7 @@ void AutomatonFromXMLParser::parseInputToPushdownStoreOperation(std::deque<sax::
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "inputToPushdownStoreOperations");
 }
 
-void AutomatonFromXMLParser::parseInputToPushdownStoreOperation(std::deque<sax::Token>& input, automaton::InputDrivenNPDA& automaton) const {
+void AutomatonFromXMLParser::parseInputToPushdownStoreOperation(std::deque<sax::Token>::iterator& input, automaton::InputDrivenNPDA& automaton) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "inputToPushdownStoreOperations");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
 		popToken(input, sax::Token::TokenType::START_ELEMENT, "operation");
@@ -689,7 +689,7 @@ void AutomatonFromXMLParser::parseInputToPushdownStoreOperation(std::deque<sax::
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "inputToPushdownStoreOperations");
 }
 
-void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, DFA& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>::iterator& input, DFA& automaton) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
 	State from = parseTransitionFrom(input);
 	alphabet::Symbol inputSymbol = parseTransitionInputSymbol(input);
@@ -699,7 +699,7 @@ void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, DFA&
 	automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(to));
 }
 
-void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, MultiInitialStateNFA& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>::iterator& input, MultiInitialStateNFA& automaton) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
 	State from = parseTransitionFrom(input);
 	alphabet::Symbol inputSymbol = parseTransitionInputSymbol(input);
@@ -709,7 +709,7 @@ void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, Mult
 	automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(to));
 }
 
-void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, NFA& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>::iterator& input, NFA& automaton) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
 	State from = parseTransitionFrom(input);
 	alphabet::Symbol inputSymbol = parseTransitionInputSymbol(input);
@@ -719,7 +719,7 @@ void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, NFA&
 	automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(to));
 }
 
-void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, EpsilonNFA& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>::iterator& input, EpsilonNFA& automaton) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
 	State from = parseTransitionFrom(input);
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant = parseTransitionInputEpsilonSymbol(input);
@@ -729,7 +729,7 @@ void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, Epsi
 	automaton.addTransition(std::move(from), std::move(inputVariant), std::move(to));
 }
 
-void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, CompactNFA& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>::iterator& input, CompactNFA& automaton) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
 	State from = parseTransitionFrom(input);
 	string::LinearString inputString = parseTransitionInputString(input);
@@ -739,7 +739,7 @@ void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, Comp
 	automaton.addTransition(std::move(from), std::move(inputString), std::move(to));
 }
 
-void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, ExtendedNFA& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>::iterator& input, ExtendedNFA& automaton) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
 	State from = parseTransitionFrom(input);
 	regexp::RegExp inputRegexp = parseTransitionInputRegexp(input);
@@ -749,7 +749,7 @@ void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, Exte
 	automaton.addTransition(std::move(from), std::move(inputRegexp), std::move(to));
 }
 
-void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, DPDA& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>::iterator& input, DPDA& automaton) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
 	State from = parseTransitionFrom(input);
 	std::variant<string::Epsilon, alphabet::Symbol> inputSymbol = parseTransitionInputEpsilonSymbol(input);
@@ -761,7 +761,7 @@ void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, DPDA
 	automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(pop), std::move(to), std::move(push));
 }
 
-void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, SinglePopDPDA& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>::iterator& input, SinglePopDPDA& automaton) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
 	State from = parseTransitionFrom(input);
 	std::variant<string::Epsilon, alphabet::Symbol> inputSymbol = parseTransitionInputEpsilonSymbol(input);
@@ -773,7 +773,7 @@ void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, Sing
 	automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(pop), std::move(to), std::move(push));
 }
 
-void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, InputDrivenDPDA& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>::iterator& input, InputDrivenDPDA& automaton) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
 	State from = parseTransitionFrom(input);
 	alphabet::Symbol inputSymbol = parseTransitionInputSymbol(input);
@@ -783,7 +783,7 @@ void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, Inpu
 	automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(to));
 }
 
-void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, InputDrivenNPDA& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>::iterator& input, InputDrivenNPDA& automaton) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
 	State from = parseTransitionFrom(input);
 	alphabet::Symbol inputSymbol = parseTransitionInputSymbol(input);
@@ -793,7 +793,7 @@ void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, Inpu
 	automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(to));
 }
 
-void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, VisiblyPushdownDPDA& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>::iterator& input, VisiblyPushdownDPDA& automaton) const {
 	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "callTransition")) {
 		popToken(input, sax::Token::TokenType::START_ELEMENT, "callTransition");
 		State from = parseTransitionFrom(input);
@@ -823,7 +823,7 @@ void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, Visi
 	}
 }
 
-void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, VisiblyPushdownNPDA& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>::iterator& input, VisiblyPushdownNPDA& automaton) const {
 	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "callTransition")) {
 		popToken(input, sax::Token::TokenType::START_ELEMENT, "callTransition");
 		State from = parseTransitionFrom(input);
@@ -853,7 +853,7 @@ void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, Visi
 	}
 }
 
-void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, RealTimeHeightDeterministicDPDA& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>::iterator& input, RealTimeHeightDeterministicDPDA& automaton) const {
 	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "callTransition")) {
 		popToken(input, sax::Token::TokenType::START_ELEMENT, "callTransition");
 		State from = parseTransitionFrom(input);
@@ -883,7 +883,7 @@ void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, Real
 	}
 }
 
-void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, RealTimeHeightDeterministicNPDA& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>::iterator& input, RealTimeHeightDeterministicNPDA& automaton) const {
 	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "callTransition")) {
 		popToken(input, sax::Token::TokenType::START_ELEMENT, "callTransition");
 		State from = parseTransitionFrom(input);
@@ -913,7 +913,7 @@ void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, Real
 	}
 }
 
-void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, NPDA& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>::iterator& input, NPDA& automaton) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
 	State from = parseTransitionFrom(input);
 	std::variant<string::Epsilon, alphabet::Symbol> inputSymbol = parseTransitionInputEpsilonSymbol(input);
@@ -925,7 +925,7 @@ void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, NPDA
 	automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(pop), std::move(to), std::move(push));
 }
 
-void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, SinglePopNPDA& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>::iterator& input, SinglePopNPDA& automaton) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
 	State from = parseTransitionFrom(input);
 	std::variant<string::Epsilon, alphabet::Symbol> inputSymbol = parseTransitionInputEpsilonSymbol(input);
@@ -937,7 +937,7 @@ void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, Sing
 	automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(pop), std::move(to), std::move(push));
 }
 
-void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, OneTapeDTM& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>::iterator& input, OneTapeDTM& automaton) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
 	State from = parseTransitionFrom(input);
 	alphabet::Symbol inputSymbol = parseTransitionInputSymbol(input);
@@ -949,7 +949,7 @@ void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, OneT
 	automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(to), std::move(outputSymbol), shift);
 }
 
-void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, DFTA& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>::iterator& input, DFTA& automaton) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
 	alphabet::RankedSymbol inputSymbol = parseTransitionInputRankedSymbol(input);
 	std::vector<State> from = parseTransitionFromMultiple(input);
@@ -959,7 +959,7 @@ void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, DFTA
 	automaton.addTransition(inputSymbol, from, to);
 }
 
-void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, NFTA& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>::iterator& input, NFTA& automaton) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
 	alphabet::RankedSymbol inputSymbol = parseTransitionInputRankedSymbol(input);
 	std::vector<State> from = parseTransitionFromMultiple(input);
@@ -969,21 +969,21 @@ void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, NFTA
 	automaton.addTransition(inputSymbol, from, to);
 }
 
-State AutomatonFromXMLParser::parseTransitionTo(std::deque<sax::Token> &input) const {
+State AutomatonFromXMLParser::parseTransitionTo(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "to");
 	State state(alib::xmlApi<label::Label>::parse(input));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "to");
 	return state;
 }
 
-State AutomatonFromXMLParser::parseTransitionFrom(std::deque<sax::Token> &input) const {
+State AutomatonFromXMLParser::parseTransitionFrom(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "from");
 	State state(alib::xmlApi<label::Label>::parse(input));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "from");
 	return state;
 }
 
-std::vector<State> AutomatonFromXMLParser::parseTransitionFromMultiple(std::deque<sax::Token> &input) const {
+std::vector<State> AutomatonFromXMLParser::parseTransitionFromMultiple(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "from");
 	std::vector<State> states;
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -993,7 +993,7 @@ std::vector<State> AutomatonFromXMLParser::parseTransitionFromMultiple(std::dequ
 	return states;
 }
 
-Shift AutomatonFromXMLParser::parseTransitionShift(std::deque<sax::Token>& input) const {
+Shift AutomatonFromXMLParser::parseTransitionShift(std::deque<sax::Token>::iterator& input) const {
 	Shift shift;
 
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "shift");
@@ -1004,15 +1004,15 @@ Shift AutomatonFromXMLParser::parseTransitionShift(std::deque<sax::Token>& input
 	} else if (isToken(input, sax::Token::TokenType::CHARACTER, "none")) {
 		shift = NONE;
 	} else {
-		throw sax::ParserException(sax::Token("", sax::Token::TokenType::CHARACTER), input.front());
+		throw sax::ParserException(sax::Token("", sax::Token::TokenType::CHARACTER), *input);
 	}
-	input.pop_front();
+	input++;
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "shift");
 
 	return shift;
 }
 
-std::vector<alphabet::Symbol> AutomatonFromXMLParser::parseTransitionPop(std::deque<sax::Token>& input) const {
+std::vector<alphabet::Symbol> AutomatonFromXMLParser::parseTransitionPop(std::deque<sax::Token>::iterator& input) const {
 	std::vector<alphabet::Symbol> pops;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "pop");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -1022,14 +1022,14 @@ std::vector<alphabet::Symbol> AutomatonFromXMLParser::parseTransitionPop(std::de
 	return pops;
 }
 
-alphabet::Symbol AutomatonFromXMLParser::parseTransitionSinglePop(std::deque<sax::Token>& input) const {
+alphabet::Symbol AutomatonFromXMLParser::parseTransitionSinglePop(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "pop");
 	alphabet::Symbol pop = alib::xmlApi<alphabet::Symbol>::parse(input);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "pop");
 	return pop;
 }
 
-std::vector<alphabet::Symbol> AutomatonFromXMLParser::parseTransitionPush(std::deque<sax::Token>& input) const {
+std::vector<alphabet::Symbol> AutomatonFromXMLParser::parseTransitionPush(std::deque<sax::Token>::iterator& input) const {
 	std::vector<alphabet::Symbol> pushes;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "push");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -1039,40 +1039,40 @@ std::vector<alphabet::Symbol> AutomatonFromXMLParser::parseTransitionPush(std::d
 	return pushes;
 }
 
-alphabet::Symbol AutomatonFromXMLParser::parseTransitionSinglePush(std::deque<sax::Token>& input) const {
+alphabet::Symbol AutomatonFromXMLParser::parseTransitionSinglePush(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "push");
 	alphabet::Symbol push = alib::xmlApi<alphabet::Symbol>::parse(input);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "push");
 	return push;
 }
 
-alphabet::Symbol AutomatonFromXMLParser::parseTransitionInputSymbol(std::deque<sax::Token>& input) const {
+alphabet::Symbol AutomatonFromXMLParser::parseTransitionInputSymbol(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "input");
 	alphabet::Symbol result(alib::xmlApi<alphabet::Symbol>::parse(input));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "input");
 	return result;
 }
 
-alphabet::RankedSymbol AutomatonFromXMLParser::parseTransitionInputRankedSymbol(std::deque<sax::Token>& input) const {
+alphabet::RankedSymbol AutomatonFromXMLParser::parseTransitionInputRankedSymbol(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "input");
 	alphabet::RankedSymbol result(alib::xmlApi<alphabet::RankedSymbol>::parse(input));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "input");
 	return result;
 }
 
-alphabet::Symbol AutomatonFromXMLParser::parseTransitionOutputSymbol(std::deque<sax::Token>& input) const {
+alphabet::Symbol AutomatonFromXMLParser::parseTransitionOutputSymbol(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "output");
 	alphabet::Symbol result(alib::xmlApi<alphabet::Symbol>::parse(input));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "output");
 	return result;
 }
 
-std::variant<string::Epsilon, alphabet::Symbol> AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol(std::deque<sax::Token>& input) const {
+std::variant<string::Epsilon, alphabet::Symbol> AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "input");
 
 	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
 		std::variant<string::Epsilon, alphabet::Symbol> result(string::Epsilon::EPSILON);
-		input.pop_front();
+		input++;
 		popToken(input, sax::Token::TokenType::END_ELEMENT, "epsilon");
 		popToken(input, sax::Token::TokenType::END_ELEMENT, "input");
 		return result;
@@ -1083,12 +1083,12 @@ std::variant<string::Epsilon, alphabet::Symbol> AutomatonFromXMLParser::parseTra
 	}
 }
 
-std::variant<string::Epsilon, alphabet::Symbol> AutomatonFromXMLParser::parseTransitionOutputEpsilonSymbol(std::deque<sax::Token>& input) const {
+std::variant<string::Epsilon, alphabet::Symbol> AutomatonFromXMLParser::parseTransitionOutputEpsilonSymbol(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "output");
 
 	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
 		std::variant<string::Epsilon, alphabet::Symbol> result(string::Epsilon::EPSILON);
-		input.pop_front();
+		input++;
 		popToken(input, sax::Token::TokenType::END_ELEMENT, "epsilon");
 		popToken(input, sax::Token::TokenType::END_ELEMENT, "output");
 		return result;
@@ -1099,14 +1099,14 @@ std::variant<string::Epsilon, alphabet::Symbol> AutomatonFromXMLParser::parseTra
 	}
 }
 
-string::LinearString AutomatonFromXMLParser::parseTransitionInputString(std::deque<sax::Token>& input) const {
+string::LinearString AutomatonFromXMLParser::parseTransitionInputString(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "input");
 	string::LinearString result(alib::xmlApi<string::LinearString>::parse(input));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "input");
 	return result;
 }
 
-regexp::RegExp AutomatonFromXMLParser::parseTransitionInputRegexp(std::deque<sax::Token>& input) const {
+regexp::RegExp AutomatonFromXMLParser::parseTransitionInputRegexp(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "input");
 	regexp::RegExp result(alib::xmlApi<regexp::RegExp>::parse(input));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "input");
diff --git a/alib2data/src/automaton/AutomatonFromXMLParser.h b/alib2data/src/automaton/AutomatonFromXMLParser.h
index 003f0ed408..ab036ce265 100644
--- a/alib2data/src/automaton/AutomatonFromXMLParser.h
+++ b/alib2data/src/automaton/AutomatonFromXMLParser.h
@@ -53,97 +53,97 @@ public:
 	AutomatonFromXMLParser() {}
 
 private:
-	std::set<State> parseStates(std::deque<sax::Token> &input) const;
-	State parseState(std::deque<sax::Token> &input) const;
-	std::set<alphabet::Symbol> parseInputAlphabet(std::deque<sax::Token> &input) const;
-	std::set<alphabet::Symbol> parseCallInputAlphabet(std::deque<sax::Token> &input) const;
-	std::set<alphabet::Symbol> parseReturnInputAlphabet(std::deque<sax::Token> &input) const;
-	std::set<alphabet::Symbol> parseLocalInputAlphabet(std::deque<sax::Token> &input) const;
-	std::set<alphabet::RankedSymbol> parseRankedInputAlphabet(std::deque<sax::Token> &input) const;
-	std::set<alphabet::Symbol> parseStackAlphabet(std::deque<sax::Token> &input) const;
-	std::set<alphabet::Symbol> parseInitialStackSymbols(std::deque<sax::Token> &input) const;
-	alphabet::Symbol parseInitialStackSymbol(std::deque<sax::Token> &input) const;
-	std::set<alphabet::Symbol> parseTapeAlphabet(std::deque<sax::Token> &input) const;
-	State parseInitialState(std::deque<sax::Token> &input) const;
-	std::set<State> parseInitialStates(std::deque<sax::Token> &input) const;
-	std::set<State> parseFinalStates(std::deque<sax::Token> &input) const;
-	alphabet::Symbol parseBlankSymbol(std::deque<sax::Token> &input) const;
-	alphabet::Symbol parseBottomOfTheStackSymbol(std::deque<sax::Token> &input) const;
-	void parseInputToPushdownStoreOperation(std::deque<sax::Token>& input, automaton::InputDrivenDPDA& automaton) const;
-	void parseInputToPushdownStoreOperation(std::deque<sax::Token>& input, automaton::InputDrivenNPDA& automaton) const;
-
-	State parseTransitionFrom(std::deque<sax::Token>& input) const;
-	std::vector<State> parseTransitionFromMultiple(std::deque<sax::Token>& input) const;
-	State parseTransitionTo(std::deque<sax::Token>& input) const;
-	Shift parseTransitionShift(std::deque<sax::Token>& input) const;
-	std::vector<alphabet::Symbol> parseTransitionPop(std::deque<sax::Token>& input) const;
-	alphabet::Symbol parseTransitionSinglePop(std::deque<sax::Token>& input) const;
-	std::vector<alphabet::Symbol> parseTransitionPush(std::deque<sax::Token>& input) const;
-	alphabet::Symbol parseTransitionSinglePush(std::deque<sax::Token>& input) const;
+	std::set<State> parseStates(std::deque<sax::Token>::iterator& input) const;
+	State parseState(std::deque<sax::Token>::iterator& input) const;
+	std::set<alphabet::Symbol> parseInputAlphabet(std::deque<sax::Token>::iterator& input) const;
+	std::set<alphabet::Symbol> parseCallInputAlphabet(std::deque<sax::Token>::iterator& input) const;
+	std::set<alphabet::Symbol> parseReturnInputAlphabet(std::deque<sax::Token>::iterator& input) const;
+	std::set<alphabet::Symbol> parseLocalInputAlphabet(std::deque<sax::Token>::iterator& input) const;
+	std::set<alphabet::RankedSymbol> parseRankedInputAlphabet(std::deque<sax::Token>::iterator& input) const;
+	std::set<alphabet::Symbol> parseStackAlphabet(std::deque<sax::Token>::iterator& input) const;
+	std::set<alphabet::Symbol> parseInitialStackSymbols(std::deque<sax::Token>::iterator& input) const;
+	alphabet::Symbol parseInitialStackSymbol(std::deque<sax::Token>::iterator& input) const;
+	std::set<alphabet::Symbol> parseTapeAlphabet(std::deque<sax::Token>::iterator& input) const;
+	State parseInitialState(std::deque<sax::Token>::iterator& input) const;
+	std::set<State> parseInitialStates(std::deque<sax::Token>::iterator& input) const;
+	std::set<State> parseFinalStates(std::deque<sax::Token>::iterator& input) const;
+	alphabet::Symbol parseBlankSymbol(std::deque<sax::Token>::iterator& input) const;
+	alphabet::Symbol parseBottomOfTheStackSymbol(std::deque<sax::Token>::iterator& input) const;
+	void parseInputToPushdownStoreOperation(std::deque<sax::Token>::iterator& input, automaton::InputDrivenDPDA& automaton) const;
+	void parseInputToPushdownStoreOperation(std::deque<sax::Token>::iterator& input, automaton::InputDrivenNPDA& automaton) const;
+
+	State parseTransitionFrom(std::deque<sax::Token>::iterator& input) const;
+	std::vector<State> parseTransitionFromMultiple(std::deque<sax::Token>::iterator& input) const;
+	State parseTransitionTo(std::deque<sax::Token>::iterator& input) const;
+	Shift parseTransitionShift(std::deque<sax::Token>::iterator& input) const;
+	std::vector<alphabet::Symbol> parseTransitionPop(std::deque<sax::Token>::iterator& input) const;
+	alphabet::Symbol parseTransitionSinglePop(std::deque<sax::Token>::iterator& input) const;
+	std::vector<alphabet::Symbol> parseTransitionPush(std::deque<sax::Token>::iterator& input) const;
+	alphabet::Symbol parseTransitionSinglePush(std::deque<sax::Token>::iterator& input) const;
 
 	template<class T>
-	void parseTransitions(std::deque<sax::Token> &input, T& automaton) const;
-
-	void parseTransition(std::deque<sax::Token>& input, EpsilonNFA& automaton) const;
-	void parseTransition(std::deque<sax::Token>& input, MultiInitialStateNFA& automaton) const;
-	void parseTransition(std::deque<sax::Token>& input, NFA& automaton) const;
-	void parseTransition(std::deque<sax::Token>& input, DFA& automaton) const;
-	void parseTransition(std::deque<sax::Token>& input, CompactNFA& automaton) const;
-	void parseTransition(std::deque<sax::Token>& input, ExtendedNFA& automaton) const;
-	void parseTransition(std::deque<sax::Token>& input, DPDA& automaton) const;
-	void parseTransition(std::deque<sax::Token>& input, SinglePopDPDA& automaton) const;
-	void parseTransition(std::deque<sax::Token>& input, InputDrivenDPDA& automaton) const;
-	void parseTransition(std::deque<sax::Token>& input, InputDrivenNPDA& automaton) const;
-	void parseTransition(std::deque<sax::Token>& input, VisiblyPushdownDPDA& automaton) const;
-	void parseTransition(std::deque<sax::Token>& input, VisiblyPushdownNPDA& automaton) const;
-	void parseTransition(std::deque<sax::Token>& input, RealTimeHeightDeterministicDPDA& automaton) const;
-	void parseTransition(std::deque<sax::Token>& input, RealTimeHeightDeterministicNPDA& automaton) const;
-	void parseTransition(std::deque<sax::Token>& input, NPDA& automaton) const;
-	void parseTransition(std::deque<sax::Token>& input, SinglePopNPDA& automaton) const;
-	void parseTransition(std::deque<sax::Token>& input, OneTapeDTM& automaton) const;
-	void parseTransition(std::deque<sax::Token>& input, DFTA& automaton) const;
-	void parseTransition(std::deque<sax::Token>& input, NFTA& automaton) const;
-
-	alphabet::Symbol parseTransitionInputSymbol(std::deque<sax::Token> &input) const;
-	alphabet::RankedSymbol parseTransitionInputRankedSymbol(std::deque<sax::Token> &input) const;
-	std::variant<string::Epsilon, alphabet::Symbol> parseTransitionInputEpsilonSymbol(std::deque<sax::Token> &input) const;
-	std::variant<string::Epsilon, alphabet::Symbol> parseTransitionInputBlankEpsilonSymbol(std::deque<sax::Token> &input) const;
-	string::LinearString parseTransitionInputString(std::deque<sax::Token> &input) const;
-	regexp::RegExp parseTransitionInputRegexp(std::deque<sax::Token> &input) const;
-
-	alphabet::Symbol parseTransitionOutputSymbol(std::deque<sax::Token> &input) const;
-	std::variant<string::Epsilon, alphabet::Symbol> parseTransitionOutputEpsilonSymbol(std::deque<sax::Token> &input) const;
-	std::variant<string::Epsilon, alphabet::Symbol> parseTransitionOutputBlankEpsilonSymbol(std::deque<sax::Token> &input) const;
-
-	alphabet::Symbol parseSymbolIO(std::deque<sax::Token> &input) const;
-	std::variant<string::Epsilon, alphabet::Symbol> parseEpsilonSymbolIO(std::deque<sax::Token> &input) const;
-
-	Automaton parseAutomaton(std::deque<sax::Token>& input) const;
-	Automaton parseAutomaton(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const;
-
-	EpsilonNFA parseEpsilonNFA(std::deque<sax::Token>& input) const;
-	MultiInitialStateNFA parseMultiInitialStateNFA(std::deque<sax::Token>& input) const;
-	NFA parseNFA(std::deque<sax::Token>& input) const;
-	DFA parseDFA(std::deque<sax::Token>& input) const;
-	CompactNFA parseCompactNFA(std::deque<sax::Token>& input) const;
-	ExtendedNFA parseExtendedNFA(std::deque<sax::Token>& input) const;
-	DPDA parseDPDA(std::deque<sax::Token>& input) const;
-	SinglePopDPDA parseSinglePopDPDA(std::deque<sax::Token>& input) const;
-	InputDrivenNPDA parseInputDrivenNPDA(std::deque<sax::Token>& input) const;
-	InputDrivenDPDA parseInputDrivenDPDA(std::deque<sax::Token>& input) const;
-	VisiblyPushdownDPDA parseVisiblyPushdownDPDA(std::deque<sax::Token>& input) const;
-	VisiblyPushdownNPDA parseVisiblyPushdownNPDA(std::deque<sax::Token>& input) const;
-	RealTimeHeightDeterministicDPDA parseRealTimeHeightDeterministicDPDA(std::deque<sax::Token>& input) const;
-	RealTimeHeightDeterministicNPDA parseRealTimeHeightDeterministicNPDA(std::deque<sax::Token>& input) const;
-	NPDA parseNPDA(std::deque<sax::Token>& input) const;
-	SinglePopNPDA parseSinglePopNPDA(std::deque<sax::Token>& input) const;
-	OneTapeDTM parseOneTapeDTM(std::deque<sax::Token>& input) const;
-	DFTA parseDFTA(std::deque<sax::Token>& input) const;
-	NFTA parseNFTA(std::deque<sax::Token>& input) const;
+	void parseTransitions(std::deque<sax::Token>::iterator& input, T& automaton) const;
+
+	void parseTransition(std::deque<sax::Token>::iterator& input, EpsilonNFA& automaton) const;
+	void parseTransition(std::deque<sax::Token>::iterator& input, MultiInitialStateNFA& automaton) const;
+	void parseTransition(std::deque<sax::Token>::iterator& input, NFA& automaton) const;
+	void parseTransition(std::deque<sax::Token>::iterator& input, DFA& automaton) const;
+	void parseTransition(std::deque<sax::Token>::iterator& input, CompactNFA& automaton) const;
+	void parseTransition(std::deque<sax::Token>::iterator& input, ExtendedNFA& automaton) const;
+	void parseTransition(std::deque<sax::Token>::iterator& input, DPDA& automaton) const;
+	void parseTransition(std::deque<sax::Token>::iterator& input, SinglePopDPDA& automaton) const;
+	void parseTransition(std::deque<sax::Token>::iterator& input, InputDrivenDPDA& automaton) const;
+	void parseTransition(std::deque<sax::Token>::iterator& input, InputDrivenNPDA& automaton) const;
+	void parseTransition(std::deque<sax::Token>::iterator& input, VisiblyPushdownDPDA& automaton) const;
+	void parseTransition(std::deque<sax::Token>::iterator& input, VisiblyPushdownNPDA& automaton) const;
+	void parseTransition(std::deque<sax::Token>::iterator& input, RealTimeHeightDeterministicDPDA& automaton) const;
+	void parseTransition(std::deque<sax::Token>::iterator& input, RealTimeHeightDeterministicNPDA& automaton) const;
+	void parseTransition(std::deque<sax::Token>::iterator& input, NPDA& automaton) const;
+	void parseTransition(std::deque<sax::Token>::iterator& input, SinglePopNPDA& automaton) const;
+	void parseTransition(std::deque<sax::Token>::iterator& input, OneTapeDTM& automaton) const;
+	void parseTransition(std::deque<sax::Token>::iterator& input, DFTA& automaton) const;
+	void parseTransition(std::deque<sax::Token>::iterator& input, NFTA& automaton) const;
+
+	alphabet::Symbol parseTransitionInputSymbol(std::deque<sax::Token>::iterator& input) const;
+	alphabet::RankedSymbol parseTransitionInputRankedSymbol(std::deque<sax::Token>::iterator& input) const;
+	std::variant<string::Epsilon, alphabet::Symbol> parseTransitionInputEpsilonSymbol(std::deque<sax::Token>::iterator& input) const;
+	std::variant<string::Epsilon, alphabet::Symbol> parseTransitionInputBlankEpsilonSymbol(std::deque<sax::Token>::iterator& input) const;
+	string::LinearString parseTransitionInputString(std::deque<sax::Token>::iterator& input) const;
+	regexp::RegExp parseTransitionInputRegexp(std::deque<sax::Token>::iterator& input) const;
+
+	alphabet::Symbol parseTransitionOutputSymbol(std::deque<sax::Token>::iterator& input) const;
+	std::variant<string::Epsilon, alphabet::Symbol> parseTransitionOutputEpsilonSymbol(std::deque<sax::Token>::iterator& input) const;
+	std::variant<string::Epsilon, alphabet::Symbol> parseTransitionOutputBlankEpsilonSymbol(std::deque<sax::Token>::iterator& input) const;
+
+	alphabet::Symbol parseSymbolIO(std::deque<sax::Token>::iterator& input) const;
+	std::variant<string::Epsilon, alphabet::Symbol> parseEpsilonSymbolIO(std::deque<sax::Token>::iterator& input) const;
+
+	Automaton parseAutomaton(std::deque<sax::Token>::iterator& input) const;
+	Automaton parseAutomaton(std::deque<sax::Token>::iterator& input, const std::set<FEATURES>& features) const;
+
+	EpsilonNFA parseEpsilonNFA(std::deque<sax::Token>::iterator& input) const;
+	MultiInitialStateNFA parseMultiInitialStateNFA(std::deque<sax::Token>::iterator& input) const;
+	NFA parseNFA(std::deque<sax::Token>::iterator& input) const;
+	DFA parseDFA(std::deque<sax::Token>::iterator& input) const;
+	CompactNFA parseCompactNFA(std::deque<sax::Token>::iterator& input) const;
+	ExtendedNFA parseExtendedNFA(std::deque<sax::Token>::iterator& input) const;
+	DPDA parseDPDA(std::deque<sax::Token>::iterator& input) const;
+	SinglePopDPDA parseSinglePopDPDA(std::deque<sax::Token>::iterator& input) const;
+	InputDrivenNPDA parseInputDrivenNPDA(std::deque<sax::Token>::iterator& input) const;
+	InputDrivenDPDA parseInputDrivenDPDA(std::deque<sax::Token>::iterator& input) const;
+	VisiblyPushdownDPDA parseVisiblyPushdownDPDA(std::deque<sax::Token>::iterator& input) const;
+	VisiblyPushdownNPDA parseVisiblyPushdownNPDA(std::deque<sax::Token>::iterator& input) const;
+	RealTimeHeightDeterministicDPDA parseRealTimeHeightDeterministicDPDA(std::deque<sax::Token>::iterator& input) const;
+	RealTimeHeightDeterministicNPDA parseRealTimeHeightDeterministicNPDA(std::deque<sax::Token>::iterator& input) const;
+	NPDA parseNPDA(std::deque<sax::Token>::iterator& input) const;
+	SinglePopNPDA parseSinglePopNPDA(std::deque<sax::Token>::iterator& input) const;
+	OneTapeDTM parseOneTapeDTM(std::deque<sax::Token>::iterator& input) const;
+	DFTA parseDFTA(std::deque<sax::Token>::iterator& input) const;
+	NFTA parseNFTA(std::deque<sax::Token>::iterator& input) const;
 
 	template<typename T> friend struct alib::xmlApi;
 public:
-	bool first(const std::deque<sax::Token>& input) const;
+	bool first(const std::deque<sax::Token>::const_iterator& input) const;
 };
 
 } /* namespace automaton */
diff --git a/alib2data/src/container/ContainerFromXMLParser.cpp b/alib2data/src/container/ContainerFromXMLParser.cpp
index 8a6289370f..b4fd7e4fe9 100644
--- a/alib2data/src/container/ContainerFromXMLParser.cpp
+++ b/alib2data/src/container/ContainerFromXMLParser.cpp
@@ -10,11 +10,11 @@
 
 namespace container {
 
-Container ContainerFromXMLParser::parseContainer(std::deque<sax::Token>& input) const {
+Container ContainerFromXMLParser::parseContainer(std::deque<sax::Token>::iterator& input) const {
 	return parseContainer(input, std::set<FEATURES>({FEATURES::SET, FEATURES::VECTOR, FEATURES::PAIR, FEATURES::MAP}));
 }
 
-Container ContainerFromXMLParser::parseContainer(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const {
+Container ContainerFromXMLParser::parseContainer(std::deque<sax::Token>::iterator& input, const std::set<FEATURES>& features) const {
 	if(alib::xmlApi<ObjectsSet>::first(input)) {
 		if(!features.count(FEATURES::SET)) throw exception::AlibException();
 		return Container(parseObjectsSet(input));
@@ -28,11 +28,11 @@ Container ContainerFromXMLParser::parseContainer(std::deque<sax::Token>& input,
 		if(!features.count(FEATURES::MAP)) throw exception::AlibException();
 		return Container(parseObjectsMap(input));
 	} else {
-		throw sax::ParserException(sax::Token("set / vector / pair / map", sax::Token::TokenType::START_ELEMENT), input.front());
+		throw sax::ParserException(sax::Token("set / vector / pair / map", sax::Token::TokenType::START_ELEMENT), *input);
 	}
 }
 
-bool ContainerFromXMLParser::first(const std::deque<sax::Token>& input) const {
+bool ContainerFromXMLParser::first(const std::deque<sax::Token>::const_iterator& input) const {
 	if(alib::xmlApi<ObjectsSet>::first(input) || alib::xmlApi<ObjectsVector>::first(input) || alib::xmlApi<ObjectsPair>::first(input) || alib::xmlApi<ObjectsMap>::first(input)) {
 		return true;
 	} else {
@@ -40,7 +40,7 @@ bool ContainerFromXMLParser::first(const std::deque<sax::Token>& input) const {
 	}
 }
 
-ObjectsSet ContainerFromXMLParser::parseObjectsSet(std::deque<sax::Token>& input) const {
+ObjectsSet ContainerFromXMLParser::parseObjectsSet(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::CONTAINER_OBJECTS_SET);
 
 	ObjectsSet set;
@@ -53,7 +53,7 @@ ObjectsSet ContainerFromXMLParser::parseObjectsSet(std::deque<sax::Token>& input
 	return set;
 }
 
-ObjectsVector ContainerFromXMLParser::parseObjectsVector(std::deque<sax::Token>& input) const {
+ObjectsVector ContainerFromXMLParser::parseObjectsVector(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::CONTAINER_OBJECTS_VECTOR);
 
 	ObjectsVector vector;
@@ -66,7 +66,7 @@ ObjectsVector ContainerFromXMLParser::parseObjectsVector(std::deque<sax::Token>&
 	return vector;
 }
 
-ObjectsPair ContainerFromXMLParser::parseObjectsPair(std::deque<sax::Token>& input) const {
+ObjectsPair ContainerFromXMLParser::parseObjectsPair(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::CONTAINER_OBJECTS_PAIR);
 
 	alib::Object first = alib::xmlApi<alib::Object>::parse(input);
@@ -78,7 +78,7 @@ ObjectsPair ContainerFromXMLParser::parseObjectsPair(std::deque<sax::Token>& inp
 	return pair;
 }
 
-ObjectsMap ContainerFromXMLParser::parseObjectsMap(std::deque<sax::Token>& input) const {
+ObjectsMap ContainerFromXMLParser::parseObjectsMap(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::CONTAINER_OBJECTS_MAP);
 
 	ObjectsMap map;
diff --git a/alib2data/src/container/ContainerFromXMLParser.hpp b/alib2data/src/container/ContainerFromXMLParser.hpp
index 7b51869a15..6fd7a02af8 100644
--- a/alib2data/src/container/ContainerFromXMLParser.hpp
+++ b/alib2data/src/container/ContainerFromXMLParser.hpp
@@ -38,36 +38,36 @@ public:
 	ContainerFromXMLParser() {}
 
 private:
-	Container parseContainer(std::deque<sax::Token>& input) const;
-	Container parseContainer(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const;
+	Container parseContainer(std::deque<sax::Token>::iterator& input) const;
+	Container parseContainer(std::deque<sax::Token>::iterator& input, const std::set<FEATURES>& features) const;
 
 	template<typename T>
-	std::set<T> parseSet(std::deque<sax::Token>& input) const;
+	std::set<T> parseSet(std::deque<sax::Token>::iterator& input) const;
 
-	ObjectsSet parseObjectsSet(std::deque<sax::Token>& input) const;
+	ObjectsSet parseObjectsSet(std::deque<sax::Token>::iterator& input) const;
 
 	template<typename T>
-	std::vector<T> parseVector(std::deque<sax::Token>& input) const;
+	std::vector<T> parseVector(std::deque<sax::Token>::iterator& input) const;
 
-	ObjectsVector parseObjectsVector(std::deque<sax::Token>& input) const;
+	ObjectsVector parseObjectsVector(std::deque<sax::Token>::iterator& input) const;
 
 	template<typename T, typename R>
-	std::pair<T, R> parsePair(std::deque<sax::Token>& input) const;
+	std::pair<T, R> parsePair(std::deque<sax::Token>::iterator& input) const;
 
-	ObjectsPair parseObjectsPair(std::deque<sax::Token>& input) const;
+	ObjectsPair parseObjectsPair(std::deque<sax::Token>::iterator& input) const;
 
 	template<typename T, typename R>
-	std::map<T, R> parseMap(std::deque<sax::Token>& input) const;
+	std::map<T, R> parseMap(std::deque<sax::Token>::iterator& input) const;
 
-	ObjectsMap parseObjectsMap(std::deque<sax::Token>& input) const;
+	ObjectsMap parseObjectsMap(std::deque<sax::Token>::iterator& input) const;
 
 	template<typename ... Ts>
-	std::variant<Ts...> parseVariant(std::deque<sax::Token>& input) const;
+	std::variant<Ts...> parseVariant(std::deque<sax::Token>::iterator& input) const;
 
 	template<typename T> friend struct alib::xmlApi;
 
 public:
-	bool first(const std::deque<sax::Token>& input) const;
+	bool first(const std::deque<sax::Token>::const_iterator& input) const;
 };
 
 } /* namespace container */
@@ -77,7 +77,7 @@ public:
 namespace container {
 
 template<typename T>
-std::set<T> ContainerFromXMLParser::parseSet(std::deque<sax::Token>& input) const {
+std::set<T> ContainerFromXMLParser::parseSet(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::CONTAINER_OBJECTS_SET);
 
 	std::set<T> set;
@@ -91,7 +91,7 @@ std::set<T> ContainerFromXMLParser::parseSet(std::deque<sax::Token>& input) cons
 }
 
 template<typename T>
-std::vector<T> ContainerFromXMLParser::parseVector(std::deque<sax::Token>& input) const {
+std::vector<T> ContainerFromXMLParser::parseVector(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::CONTAINER_OBJECTS_VECTOR);
 
 	std::vector<T> vector;
@@ -105,7 +105,7 @@ std::vector<T> ContainerFromXMLParser::parseVector(std::deque<sax::Token>& input
 }
 
 template<typename T, typename R>
-std::pair<T, R> ContainerFromXMLParser::parsePair(std::deque<sax::Token>& input) const {
+std::pair<T, R> ContainerFromXMLParser::parsePair(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::CONTAINER_OBJECTS_PAIR);
 
 	T first = alib::xmlApi<T>::parse(input);
@@ -116,7 +116,7 @@ std::pair<T, R> ContainerFromXMLParser::parsePair(std::deque<sax::Token>& input)
 }
 
 template<typename T, typename R>
-std::map<T, R> ContainerFromXMLParser::parseMap(std::deque<sax::Token>& input) const {
+std::map<T, R> ContainerFromXMLParser::parseMap(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::CONTAINER_OBJECTS_MAP);
 
 	std::map<T, R> map;
@@ -131,18 +131,18 @@ std::map<T, R> ContainerFromXMLParser::parseMap(std::deque<sax::Token>& input) c
 
 /* TODO for gcc-4.9 uncoment this
 template<typename T>
-T parseVariantHelper(std::deque<sax::Token>&) {
+T parseVariantHelper(std::deque<sax::Token>::iterator&) {
 	throw exception::AlibException("Can't parse variant type");
 }
 
 template<typename T, typename R, typename ... Ts>
-T parseVariantHelper(std::deque<sax::Token>& input) {
+T parseVariantHelper(std::deque<sax::Token>::iterator& input) {
 	if(alib::xmlApi<R>::first(input)) return T(alib::xmlApi<R>::parse(input));
 	return parseVariantHelper<T, Ts...>(input);
 }
 
 template<typename ... Ts>
-std::variant<Ts...> ContainerFromXMLParser::parseVariant(std::deque<sax::Token>& input) const {
+std::variant<Ts...> ContainerFromXMLParser::parseVariant(std::deque<sax::Token>::iterator& input) const {
 	return parseVariantHelper<std::variant<Ts...>, Ts...>(input);
 }
 */
diff --git a/alib2data/src/exception/ExceptionFromXMLParser.cpp b/alib2data/src/exception/ExceptionFromXMLParser.cpp
index 6aacffaecd..b477e99fef 100644
--- a/alib2data/src/exception/ExceptionFromXMLParser.cpp
+++ b/alib2data/src/exception/ExceptionFromXMLParser.cpp
@@ -13,32 +13,32 @@
 
 namespace exception {
 
-AlibException ExceptionFromXMLParser::parseException(std::deque<sax::Token>& input) const {
+AlibException ExceptionFromXMLParser::parseException(std::deque<sax::Token>::iterator& input) const {
 	return parseException(input, std::set<FEATURES>({FEATURES::ALIB_EXCEPTION}));
 }
 
-AlibException ExceptionFromXMLParser::parseException(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const {
+AlibException ExceptionFromXMLParser::parseException(std::deque<sax::Token>::iterator& input, const std::set<FEATURES>& features) const {
 	if(!features.count(FEATURES::ALIB_EXCEPTION)) throw exception::AlibException();
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::EXCEPTION_ALIB_EXCEPTION);
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "cause");
 	std::string cause = "";
-	if (input.front().getType() == sax::Token::TokenType::CHARACTER) {
-		cause = input.front().getData();
-		input.pop_front();
+	if (input->getType() == sax::Token::TokenType::CHARACTER) {
+		cause = std::move(*input).moveData();
+		input++;
 	}
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "cause");
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "backtrace");
 	std::string backtrace = "";
-	if (input.front().getType() == sax::Token::TokenType::CHARACTER) {
-		backtrace = input.front().getData();
-		input.pop_front();
+	if (input->getType() == sax::Token::TokenType::CHARACTER) {
+		backtrace = std::move(*input).moveData();
+		input++;
 	}
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "backtrace");
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::EXCEPTION_ALIB_EXCEPTION);
 	return AlibException(std::move(cause), std::move(backtrace));
 }
 
-bool ExceptionFromXMLParser::first(const std::deque<sax::Token>& input) const {
+bool ExceptionFromXMLParser::first(const std::deque<sax::Token>::const_iterator& input) const {
 	if(alib::xmlApi<AlibException>::first(input)) {
 		return true;
 	} else {
diff --git a/alib2data/src/exception/ExceptionFromXMLParser.h b/alib2data/src/exception/ExceptionFromXMLParser.h
index 4c5ad16d9c..837df3736b 100644
--- a/alib2data/src/exception/ExceptionFromXMLParser.h
+++ b/alib2data/src/exception/ExceptionFromXMLParser.h
@@ -31,11 +31,11 @@ public:
 	ExceptionFromXMLParser() {}
 
 private:
-	AlibException parseException(std::deque<sax::Token>& input) const;
-	AlibException parseException(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const;
+	AlibException parseException(std::deque<sax::Token>::iterator& input) const;
+	AlibException parseException(std::deque<sax::Token>::iterator& input, const std::set<FEATURES>& features) const;
 
 public:
-	bool first(const std::deque<sax::Token>& input) const;
+	bool first(const std::deque<sax::Token>::const_iterator& input) const;
 
 	template<typename T> friend struct alib::xmlApi;
 };
diff --git a/alib2data/src/factory/XmlDataFactory.hpp b/alib2data/src/factory/XmlDataFactory.hpp
index a76acd0062..eba2629252 100644
--- a/alib2data/src/factory/XmlDataFactory.hpp
+++ b/alib2data/src/factory/XmlDataFactory.hpp
@@ -77,14 +77,16 @@ public:
 	 */
 	template<class T>
 	static T fromTokens(std::deque<sax::Token>& tokens) {
-		if(tokens.size() == 0) throw exception::AlibException("Empty tokens list");
+		std::deque<sax::Token>::iterator iter = tokens.begin();
 
-		if(alib::xmlApi<exception::AlibException>::first(tokens)) throw alib::xmlApi<exception::AlibException>::parse(tokens);
+		if(iter == tokens.end()) throw exception::AlibException("Empty tokens list");
+
+		if(alib::xmlApi<exception::AlibException>::first(iter)) throw alib::xmlApi<exception::AlibException>::parse(iter);
 
 		std::chrono::measurements::start("XML Parser", std::chrono::measurements::Type::INIT);
-		T res = alib::xmlApi<T>::parse(tokens);
+		T res = alib::xmlApi<T>::parse(iter);
 		std::chrono::measurements::end();
-		if(tokens.size() != 0) throw exception::AlibException("Unexpeted tokens at the end of the xml");
+		if(iter != tokens.end()) throw exception::AlibException("Unexpeted tokens at the end of the xml");
 		return res;
 	}
 
@@ -95,7 +97,7 @@ public:
 	 */
 	template<class T>
 	static bool first(const std::deque<sax::Token>& tokens) {
-		return alib::xmlApi<exception::AlibException>::first(tokens) || alib::xmlApi<T>::first(tokens);
+		return alib::xmlApi<exception::AlibException>::first(tokens.begin()) || alib::xmlApi<T>::first(tokens.begin());
 	}
 
 	/**
@@ -160,15 +162,17 @@ public:
 
 template<>
 inline bool XmlDataFactory::first<exception::AlibException>(const std::deque<sax::Token>& tokens) {
-	return alib::xmlApi<exception::AlibException>::first(tokens);
+	return alib::xmlApi<exception::AlibException>::first(tokens.begin());
 }
 
 template<>
 inline exception::AlibException XmlDataFactory::fromTokens<exception::AlibException>(std::deque<sax::Token>& tokens) {
-	if(tokens.size() == 0) throw exception::AlibException("Empty tokens list");
+	std::deque<sax::Token>::iterator iter = tokens.begin();
+
+	if(iter == tokens.end()) throw exception::AlibException("Empty tokens list");
 
-	exception::AlibException res = alib::xmlApi<exception::AlibException>::parse(tokens);
-	if(tokens.size() != 0) throw exception::AlibException("Unexpeted tokens at the end of the xml");
+	exception::AlibException res = alib::xmlApi<exception::AlibException>::parse(iter);
+	if(iter != tokens.end()) throw exception::AlibException("Unexpeted tokens at the end of the xml");
 	return res;
 }
 
diff --git a/alib2data/src/grammar/GrammarFromXMLParser.cpp b/alib2data/src/grammar/GrammarFromXMLParser.cpp
index b936cc22f7..4259503c8c 100644
--- a/alib2data/src/grammar/GrammarFromXMLParser.cpp
+++ b/alib2data/src/grammar/GrammarFromXMLParser.cpp
@@ -14,11 +14,11 @@
 
 namespace grammar {
 
-Grammar GrammarFromXMLParser::parseGrammar(std::deque<sax::Token> &input) const {
+Grammar GrammarFromXMLParser::parseGrammar(std::deque<sax::Token>::iterator& input) const {
 	return parseGrammar(input, std::set<FEATURES>({FEATURES::LEFT_LG, FEATURES::LEFT_RG, FEATURES::RIGHT_LG, FEATURES::RIGHT_RG, FEATURES::LG, FEATURES::CFG, FEATURES::EPSILON_FREE_CFG, FEATURES::CNF, FEATURES::GNF, FEATURES::CSG, FEATURES::NON_CONTRACTING_GRAMMAR, FEATURES::CONTEXT_PRESERVING_UNRESTRICTED_GRAMMAR, FEATURES::UNRESTRICTED_GRAMMAR}));
 }
 
-Grammar GrammarFromXMLParser::parseGrammar(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const {
+Grammar GrammarFromXMLParser::parseGrammar(std::deque<sax::Token>::iterator& input, const std::set<FEATURES>& features) const {
 	if(alib::xmlApi<UnrestrictedGrammar>::first(input)) {
 		if(!features.count(FEATURES::UNRESTRICTED_GRAMMAR)) throw exception::AlibException();
 		return Grammar(parseUnrestrictedGrammar(input));
@@ -59,10 +59,10 @@ Grammar GrammarFromXMLParser::parseGrammar(std::deque<sax::Token>& input, const
 		if(!features.count(FEATURES::LEFT_LG)) throw exception::AlibException();
 		return Grammar(parseLeftLG(input));
 	} else
-		throw sax::ParserException(sax::Token("Grammar / UnrestrictedGrammar", sax::Token::TokenType::START_ELEMENT), input.front());
+		throw sax::ParserException(sax::Token("Grammar / UnrestrictedGrammar", sax::Token::TokenType::START_ELEMENT), *input);
 }
 
-bool GrammarFromXMLParser::first(const std::deque<sax::Token>& input) const {
+bool GrammarFromXMLParser::first(const std::deque<sax::Token>::const_iterator& input) const {
 	if(alib::xmlApi<UnrestrictedGrammar>::first(input) || alib::xmlApi<ContextPreservingUnrestrictedGrammar>::first(input) || alib::xmlApi<NonContractingGrammar>::first(input) || alib::xmlApi<CSG>::first(input) || alib::xmlApi<GNF>::first(input) || alib::xmlApi<CNF>::first(input) || alib::xmlApi<EpsilonFreeCFG>::first(input) || alib::xmlApi<CFG>::first(input) || alib::xmlApi<LG>::first(input) || alib::xmlApi<RightRG>::first(input) || alib::xmlApi<RightLG>::first(input) || alib::xmlApi<LeftLG>::first(input) || alib::xmlApi<LeftRG>::first(input)) {
 		return true;
 	} else {
@@ -70,7 +70,7 @@ bool GrammarFromXMLParser::first(const std::deque<sax::Token>& input) const {
 	}
 }
 
-UnrestrictedGrammar GrammarFromXMLParser::parseUnrestrictedGrammar(std::deque<sax::Token>& input) const {
+UnrestrictedGrammar GrammarFromXMLParser::parseUnrestrictedGrammar(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_UNRESTRICTED_GRAMMAR);
 
 	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
@@ -87,7 +87,7 @@ UnrestrictedGrammar GrammarFromXMLParser::parseUnrestrictedGrammar(std::deque<sa
 	return grammar;
 }
 
-ContextPreservingUnrestrictedGrammar GrammarFromXMLParser::parseContextPreservingUnrestrictedGrammar(std::deque<sax::Token>& input) const {
+ContextPreservingUnrestrictedGrammar GrammarFromXMLParser::parseContextPreservingUnrestrictedGrammar(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_CONTEXT_PRESERVING_UNRESTRICTED_GRAMMAR);
 
 	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
@@ -104,7 +104,7 @@ ContextPreservingUnrestrictedGrammar GrammarFromXMLParser::parseContextPreservin
 	return grammar;
 }
 
-NonContractingGrammar GrammarFromXMLParser::parseNonContractingGrammar(std::deque<sax::Token>& input) const {
+NonContractingGrammar GrammarFromXMLParser::parseNonContractingGrammar(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_NON_CONTRACTING_GRAMMAR);
 
 	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
@@ -124,7 +124,7 @@ NonContractingGrammar GrammarFromXMLParser::parseNonContractingGrammar(std::dequ
 	return grammar;
 }
 
-CSG GrammarFromXMLParser::parseCSG(std::deque<sax::Token>& input) const {
+CSG GrammarFromXMLParser::parseCSG(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_CSG);
 
 	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
@@ -144,7 +144,7 @@ CSG GrammarFromXMLParser::parseCSG(std::deque<sax::Token>& input) const {
 	return grammar;
 }
 
-GNF GrammarFromXMLParser::parseGNF(std::deque<sax::Token>& input) const {
+GNF GrammarFromXMLParser::parseGNF(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_GNF);
 
 	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
@@ -164,7 +164,7 @@ GNF GrammarFromXMLParser::parseGNF(std::deque<sax::Token>& input) const {
 	return grammar;
 }
 
-CNF GrammarFromXMLParser::parseCNF(std::deque<sax::Token>& input) const {
+CNF GrammarFromXMLParser::parseCNF(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_CNF);
 
 	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
@@ -184,7 +184,7 @@ CNF GrammarFromXMLParser::parseCNF(std::deque<sax::Token>& input) const {
 	return grammar;
 }
 
-EpsilonFreeCFG GrammarFromXMLParser::parseEpsilonFreeCFG(std::deque<sax::Token>& input) const {
+EpsilonFreeCFG GrammarFromXMLParser::parseEpsilonFreeCFG(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_EPSILON_FREE_CFG);
 
 	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
@@ -204,7 +204,7 @@ EpsilonFreeCFG GrammarFromXMLParser::parseEpsilonFreeCFG(std::deque<sax::Token>&
 	return grammar;
 }
 
-CFG GrammarFromXMLParser::parseCFG(std::deque<sax::Token>& input) const {
+CFG GrammarFromXMLParser::parseCFG(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_CFG);
 
 	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
@@ -221,7 +221,7 @@ CFG GrammarFromXMLParser::parseCFG(std::deque<sax::Token>& input) const {
 	return grammar;
 }
 
-LG GrammarFromXMLParser::parseLG(std::deque<sax::Token>& input) const {
+LG GrammarFromXMLParser::parseLG(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_LG);
 
 	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
@@ -238,7 +238,7 @@ LG GrammarFromXMLParser::parseLG(std::deque<sax::Token>& input) const {
 	return grammar;
 }
 
-RightRG GrammarFromXMLParser::parseRightRG(std::deque<sax::Token>& input) const {
+RightRG GrammarFromXMLParser::parseRightRG(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_RIGHT_RG);
 
 	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
@@ -258,7 +258,7 @@ RightRG GrammarFromXMLParser::parseRightRG(std::deque<sax::Token>& input) const
 	return grammar;
 }
 
-RightLG GrammarFromXMLParser::parseRightLG(std::deque<sax::Token>& input) const {
+RightLG GrammarFromXMLParser::parseRightLG(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_RIGHT_LG);
 
 	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
@@ -275,7 +275,7 @@ RightLG GrammarFromXMLParser::parseRightLG(std::deque<sax::Token>& input) const
 	return grammar;
 }
 
-LeftRG GrammarFromXMLParser::parseLeftRG(std::deque<sax::Token>& input) const {
+LeftRG GrammarFromXMLParser::parseLeftRG(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_LEFT_RG);
 
 	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
@@ -295,7 +295,7 @@ LeftRG GrammarFromXMLParser::parseLeftRG(std::deque<sax::Token>& input) const {
 	return grammar;
 }
 
-LeftLG GrammarFromXMLParser::parseLeftLG(std::deque<sax::Token>& input) const {
+LeftLG GrammarFromXMLParser::parseLeftLG(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_LEFT_LG);
 
 	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
@@ -313,7 +313,7 @@ LeftLG GrammarFromXMLParser::parseLeftLG(std::deque<sax::Token>& input) const {
 }
 
 
-std::set<alphabet::Symbol> GrammarFromXMLParser::parseNonterminalAlphabet(std::deque<sax::Token> &input) const {
+std::set<alphabet::Symbol> GrammarFromXMLParser::parseNonterminalAlphabet(std::deque<sax::Token>::iterator& input) const {
 	std::set<alphabet::Symbol> inputSymbols;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "nonterminalAlphabet");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -323,7 +323,7 @@ std::set<alphabet::Symbol> GrammarFromXMLParser::parseNonterminalAlphabet(std::d
 	return inputSymbols;
 }
 
-std::set<alphabet::Symbol> GrammarFromXMLParser::parseTerminalAlphabet(std::deque<sax::Token> &input) const {
+std::set<alphabet::Symbol> GrammarFromXMLParser::parseTerminalAlphabet(std::deque<sax::Token>::iterator& input) const {
 	std::set<alphabet::Symbol> inputSymbols;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "terminalAlphabet");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -333,18 +333,18 @@ std::set<alphabet::Symbol> GrammarFromXMLParser::parseTerminalAlphabet(std::dequ
 	return inputSymbols;
 }
 
-alphabet::Symbol GrammarFromXMLParser::parseInitialSymbol(std::deque<sax::Token>& input) const {
+alphabet::Symbol GrammarFromXMLParser::parseInitialSymbol(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "initialSymbol");
 	alphabet::Symbol blank(alib::xmlApi<alphabet::Symbol>::parse(input));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "initialSymbol");
 	return blank;
 }
 
-bool GrammarFromXMLParser::parseGeneratesEpsilon(std::deque<sax::Token>& input) const {
+bool GrammarFromXMLParser::parseGeneratesEpsilon(std::deque<sax::Token>::iterator& input) const {
 	bool generatesEpsilon;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "generatesEpsilon");
 	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "true")) {
-		input.pop_front();
+		input++;
 		popToken(input, sax::Token::TokenType::END_ELEMENT, "true");
 		generatesEpsilon = true;
 	} else {
@@ -357,7 +357,7 @@ bool GrammarFromXMLParser::parseGeneratesEpsilon(std::deque<sax::Token>& input)
 }
 
 template<class T>
-void GrammarFromXMLParser::parseRules(std::deque<sax::Token> &input, T& grammar) const {
+void GrammarFromXMLParser::parseRules(std::deque<sax::Token>::iterator& input, T& grammar) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "rules");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
 		popToken(input, sax::Token::TokenType::START_ELEMENT, "rule");
@@ -367,13 +367,13 @@ void GrammarFromXMLParser::parseRules(std::deque<sax::Token> &input, T& grammar)
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "rules");
 }
 
-void GrammarFromXMLParser::parseRule(std::deque<sax::Token>& input, UnrestrictedGrammar& grammar) const {
+void GrammarFromXMLParser::parseRule(std::deque<sax::Token>::iterator& input, UnrestrictedGrammar& grammar) const {
 	std::vector<alphabet::Symbol> lhs = parseRuleLHS(input);
 	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
 	grammar.addRule(std::move(lhs), std::move(rhs));
 }
 
-void GrammarFromXMLParser::parseRule(std::deque<sax::Token>& input, ContextPreservingUnrestrictedGrammar& grammar) const {
+void GrammarFromXMLParser::parseRule(std::deque<sax::Token>::iterator& input, ContextPreservingUnrestrictedGrammar& grammar) const {
 	std::vector<alphabet::Symbol> lContext = parseRuleLContext(input);
 	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
 	std::vector<alphabet::Symbol> rContext = parseRuleRContext(input);
@@ -381,13 +381,13 @@ void GrammarFromXMLParser::parseRule(std::deque<sax::Token>& input, ContextPrese
 	grammar.addRule(std::move(lContext), std::move(lhs), std::move(rContext), std::move(rhs));
 }
 
-void GrammarFromXMLParser::parseRule(std::deque<sax::Token>& input, NonContractingGrammar& grammar) const {
+void GrammarFromXMLParser::parseRule(std::deque<sax::Token>::iterator& input, NonContractingGrammar& grammar) const {
 	std::vector<alphabet::Symbol> lhs = parseRuleLHS(input);
 	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
 	grammar.addRule(std::move(lhs), std::move(rhs));
 }
 
-void GrammarFromXMLParser::parseRule(std::deque<sax::Token>& input, CSG& grammar) const {
+void GrammarFromXMLParser::parseRule(std::deque<sax::Token>::iterator& input, CSG& grammar) const {
 	std::vector<alphabet::Symbol> lContext = parseRuleLContext(input);
 	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
 	std::vector<alphabet::Symbol> rContext = parseRuleRContext(input);
@@ -395,66 +395,66 @@ void GrammarFromXMLParser::parseRule(std::deque<sax::Token>& input, CSG& grammar
 	grammar.addRule(std::move(lContext), std::move(lhs), std::move(rContext), std::move(rhs));
 }
 
-void GrammarFromXMLParser::parseRule(std::deque<sax::Token>& input, GNF& grammar) const {
+void GrammarFromXMLParser::parseRule(std::deque<sax::Token>::iterator& input, GNF& grammar) const {
 	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
 	std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>> rhs = parseRuleGNFRHS(input);
 	grammar.addRule(std::move(lhs), std::move(rhs));
 }
 
-void GrammarFromXMLParser::parseRule(std::deque<sax::Token>& input, CNF& grammar) const {
+void GrammarFromXMLParser::parseRule(std::deque<sax::Token>::iterator& input, CNF& grammar) const {
 	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
 	std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> rhs = parseRuleOneOrTwoSymbolsRHS(input);
 	grammar.addRule(std::move(lhs), std::move(rhs));
 }
 
-void GrammarFromXMLParser::parseRule(std::deque<sax::Token>& input, EpsilonFreeCFG& grammar) const {
+void GrammarFromXMLParser::parseRule(std::deque<sax::Token>::iterator& input, EpsilonFreeCFG& grammar) const {
 	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
 	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
 	grammar.addRule(std::move(lhs), std::move(rhs));
 }
 
-void GrammarFromXMLParser::parseRule(std::deque<sax::Token>& input, CFG& grammar) const {
+void GrammarFromXMLParser::parseRule(std::deque<sax::Token>::iterator& input, CFG& grammar) const {
 	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
 	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
 	grammar.addRule(std::move(lhs), std::move(rhs));
 }
 
-void GrammarFromXMLParser::parseRule(std::deque<sax::Token>& input, LG& grammar) const {
+void GrammarFromXMLParser::parseRule(std::deque<sax::Token>::iterator& input, LG& grammar) const {
 	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
 	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
 	grammar.addRawRule(std::move(lhs), std::move(rhs));
 }
 
-void GrammarFromXMLParser::parseRule(std::deque<sax::Token>& input, RightRG& grammar) const {
+void GrammarFromXMLParser::parseRule(std::deque<sax::Token>::iterator& input, RightRG& grammar) const {
 	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
 	std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> rhs = parseRuleOneOrTwoSymbolsRHS(input);
 	grammar.addRule(std::move(lhs), std::move(rhs));
 }
 
-void GrammarFromXMLParser::parseRule(std::deque<sax::Token>& input, RightLG& grammar) const {
+void GrammarFromXMLParser::parseRule(std::deque<sax::Token>::iterator& input, RightLG& grammar) const {
 	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
 	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
 	grammar.addRawRule(std::move(lhs), std::move(rhs));
 }
 
-void GrammarFromXMLParser::parseRule(std::deque<sax::Token>& input, LeftRG& grammar) const {
+void GrammarFromXMLParser::parseRule(std::deque<sax::Token>::iterator& input, LeftRG& grammar) const {
 	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
 	std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> rhs = parseRuleOneOrTwoSymbolsRHS(input);
 	grammar.addRule(std::move(lhs), std::move(rhs));
 }
 
-void GrammarFromXMLParser::parseRule(std::deque<sax::Token>& input, LeftLG& grammar) const {
+void GrammarFromXMLParser::parseRule(std::deque<sax::Token>::iterator& input, LeftLG& grammar) const {
 	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
 	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
 	grammar.addRawRule(std::move(lhs), std::move(rhs));
 }
 
 
-std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleLContext(std::deque<sax::Token>& input) const {
+std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleLContext(std::deque<sax::Token>::iterator& input) const {
 	std::vector<alphabet::Symbol> lContext;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "lContext");
 	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
-		input.pop_front();
+		input++;
 		popToken(input, sax::Token::TokenType::END_ELEMENT, "epsilon");
 	} else while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
 		lContext.push_back(alib::xmlApi<alphabet::Symbol>::parse(input));
@@ -463,11 +463,11 @@ std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleLContext(std::deque
 	return lContext;
 }
 
-std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleLHS(std::deque<sax::Token>& input) const {
+std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleLHS(std::deque<sax::Token>::iterator& input) const {
 	std::vector<alphabet::Symbol> lhs;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "lhs");
 	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
-		input.pop_front();
+		input++;
 		popToken(input, sax::Token::TokenType::END_ELEMENT, "epsilon");
 	} else while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
 		lhs.push_back(alib::xmlApi<alphabet::Symbol>::parse(input));
@@ -476,18 +476,18 @@ std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleLHS(std::deque<sax:
 	return lhs;
 }
 
-alphabet::Symbol GrammarFromXMLParser::parseRuleSingleSymbolLHS(std::deque<sax::Token>& input) const {
+alphabet::Symbol GrammarFromXMLParser::parseRuleSingleSymbolLHS(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "lhs");
 	alphabet::Symbol lhs = alib::xmlApi<alphabet::Symbol>::parse(input);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "lhs");
 	return lhs;
 }
 
-std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleRContext(std::deque<sax::Token>& input) const {
+std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleRContext(std::deque<sax::Token>::iterator& input) const {
 	std::vector<alphabet::Symbol> rContext;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "rContext");
 	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
-		input.pop_front();
+		input++;
 		popToken(input, sax::Token::TokenType::END_ELEMENT, "epsilon");
 	} else while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
 		rContext.push_back(alib::xmlApi<alphabet::Symbol>::parse(input));
@@ -496,7 +496,7 @@ std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleRContext(std::deque
 	return rContext;
 }
 
-std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>> GrammarFromXMLParser::parseRuleGNFRHS(std::deque<sax::Token>& input) const {
+std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>> GrammarFromXMLParser::parseRuleGNFRHS(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "rhs");
 	alphabet::Symbol first = alib::xmlApi<alphabet::Symbol>::parse(input);
 	std::vector<alphabet::Symbol> second;
@@ -507,11 +507,11 @@ std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>> GrammarFromXMLParser:
 	return std::make_pair(std::move(first), std::move(second));
 }
 
-std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleRHS(std::deque<sax::Token>& input) const {
+std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleRHS(std::deque<sax::Token>::iterator& input) const {
 	std::vector<alphabet::Symbol> rhs;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "rhs");
 	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
-		input.pop_front();
+		input++;
 		popToken(input, sax::Token::TokenType::END_ELEMENT, "epsilon");
 	} else while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
 		rhs.push_back(alib::xmlApi<alphabet::Symbol>::parse(input));
@@ -520,7 +520,7 @@ std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleRHS(std::deque<sax:
 	return rhs;
 }
 
-std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS(std::deque<sax::Token>& input) const {
+std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "rhs");
 	alphabet::Symbol first = alib::xmlApi<alphabet::Symbol>::parse(input);
 	if(isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
diff --git a/alib2data/src/grammar/GrammarFromXMLParser.h b/alib2data/src/grammar/GrammarFromXMLParser.h
index f65ec3b3af..23527cb9d2 100644
--- a/alib2data/src/grammar/GrammarFromXMLParser.h
+++ b/alib2data/src/grammar/GrammarFromXMLParser.h
@@ -47,56 +47,56 @@ public:
 	GrammarFromXMLParser() {}
 
 private:
-	std::set<alphabet::Symbol> parseNonterminalAlphabet(std::deque<sax::Token> &input) const;
-	std::set<alphabet::Symbol> parseTerminalAlphabet(std::deque<sax::Token> &input) const;
-	alphabet::Symbol parseInitialSymbol(std::deque<sax::Token> &input) const;
-	bool parseGeneratesEpsilon(std::deque<sax::Token> &input) const;
-
-	std::vector<alphabet::Symbol> parseRuleLContext(std::deque<sax::Token>& input) const;
-	std::vector<alphabet::Symbol> parseRuleLHS(std::deque<sax::Token>& input) const;
-	std::vector<alphabet::Symbol> parseRuleRContext(std::deque<sax::Token>& input) const;
-	alphabet::Symbol parseRuleSingleSymbolLHS(std::deque<sax::Token>& input) const;
-	std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>> parseRuleGNFRHS(std::deque<sax::Token>& input) const;
-	std::vector<alphabet::Symbol> parseRuleRHS(std::deque<sax::Token>& input) const;
-	std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> parseRuleOneOrTwoSymbolsRHS(std::deque<sax::Token>& input) const;
+	std::set<alphabet::Symbol> parseNonterminalAlphabet(std::deque<sax::Token>::iterator& input) const;
+	std::set<alphabet::Symbol> parseTerminalAlphabet(std::deque<sax::Token>::iterator& input) const;
+	alphabet::Symbol parseInitialSymbol(std::deque<sax::Token>::iterator& input) const;
+	bool parseGeneratesEpsilon(std::deque<sax::Token>::iterator& input) const;
+
+	std::vector<alphabet::Symbol> parseRuleLContext(std::deque<sax::Token>::iterator& input) const;
+	std::vector<alphabet::Symbol> parseRuleLHS(std::deque<sax::Token>::iterator& input) const;
+	std::vector<alphabet::Symbol> parseRuleRContext(std::deque<sax::Token>::iterator& input) const;
+	alphabet::Symbol parseRuleSingleSymbolLHS(std::deque<sax::Token>::iterator& input) const;
+	std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>> parseRuleGNFRHS(std::deque<sax::Token>::iterator& input) const;
+	std::vector<alphabet::Symbol> parseRuleRHS(std::deque<sax::Token>::iterator& input) const;
+	std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> parseRuleOneOrTwoSymbolsRHS(std::deque<sax::Token>::iterator& input) const;
 
 	template<class T>
-	void parseRules(std::deque<sax::Token> &input, T& grammar) const;
-
-	void parseRule(std::deque<sax::Token>& input, UnrestrictedGrammar& grammar) const;
-	void parseRule(std::deque<sax::Token>& input, ContextPreservingUnrestrictedGrammar& grammar) const;
-	void parseRule(std::deque<sax::Token>& input, NonContractingGrammar& grammar) const;
-	void parseRule(std::deque<sax::Token>& input, CSG& grammar) const;
-	void parseRule(std::deque<sax::Token>& input, GNF& grammar) const;
-	void parseRule(std::deque<sax::Token>& input, CNF& grammar) const;
-	void parseRule(std::deque<sax::Token>& input, EpsilonFreeCFG& grammar) const;
-	void parseRule(std::deque<sax::Token>& input, CFG& grammar) const;
-	void parseRule(std::deque<sax::Token>& input, LG& grammar) const;
-	void parseRule(std::deque<sax::Token>& input, RightRG& grammar) const;
-	void parseRule(std::deque<sax::Token>& input, RightLG& grammar) const;
-	void parseRule(std::deque<sax::Token>& input, LeftRG& grammar) const;
-	void parseRule(std::deque<sax::Token>& input, LeftLG& grammar) const;
-
-	Grammar parseGrammar(std::deque<sax::Token>& input) const;
-	Grammar parseGrammar(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const;
-
-	UnrestrictedGrammar parseUnrestrictedGrammar(std::deque<sax::Token>& input) const;
-	ContextPreservingUnrestrictedGrammar parseContextPreservingUnrestrictedGrammar(std::deque<sax::Token>& input) const;
-	NonContractingGrammar parseNonContractingGrammar(std::deque<sax::Token>& input) const;
-	CSG parseCSG(std::deque<sax::Token>& input) const;
-	GNF parseGNF(std::deque<sax::Token>& input) const;
-	CNF parseCNF(std::deque<sax::Token>& input) const;
-	EpsilonFreeCFG parseEpsilonFreeCFG(std::deque<sax::Token>& input) const;
-	CFG parseCFG(std::deque<sax::Token>& input) const;
-	LG parseLG(std::deque<sax::Token>& input) const;
-	RightRG parseRightRG(std::deque<sax::Token>& input) const;
-	RightLG parseRightLG(std::deque<sax::Token>& input) const;
-	LeftRG parseLeftRG(std::deque<sax::Token>& input) const;
-	LeftLG parseLeftLG(std::deque<sax::Token>& input) const;
+	void parseRules(std::deque<sax::Token>::iterator& input, T& grammar) const;
+
+	void parseRule(std::deque<sax::Token>::iterator& input, UnrestrictedGrammar& grammar) const;
+	void parseRule(std::deque<sax::Token>::iterator& input, ContextPreservingUnrestrictedGrammar& grammar) const;
+	void parseRule(std::deque<sax::Token>::iterator& input, NonContractingGrammar& grammar) const;
+	void parseRule(std::deque<sax::Token>::iterator& input, CSG& grammar) const;
+	void parseRule(std::deque<sax::Token>::iterator& input, GNF& grammar) const;
+	void parseRule(std::deque<sax::Token>::iterator& input, CNF& grammar) const;
+	void parseRule(std::deque<sax::Token>::iterator& input, EpsilonFreeCFG& grammar) const;
+	void parseRule(std::deque<sax::Token>::iterator& input, CFG& grammar) const;
+	void parseRule(std::deque<sax::Token>::iterator& input, LG& grammar) const;
+	void parseRule(std::deque<sax::Token>::iterator& input, RightRG& grammar) const;
+	void parseRule(std::deque<sax::Token>::iterator& input, RightLG& grammar) const;
+	void parseRule(std::deque<sax::Token>::iterator& input, LeftRG& grammar) const;
+	void parseRule(std::deque<sax::Token>::iterator& input, LeftLG& grammar) const;
+
+	Grammar parseGrammar(std::deque<sax::Token>::iterator& input) const;
+	Grammar parseGrammar(std::deque<sax::Token>::iterator& input, const std::set<FEATURES>& features) const;
+
+	UnrestrictedGrammar parseUnrestrictedGrammar(std::deque<sax::Token>::iterator& input) const;
+	ContextPreservingUnrestrictedGrammar parseContextPreservingUnrestrictedGrammar(std::deque<sax::Token>::iterator& input) const;
+	NonContractingGrammar parseNonContractingGrammar(std::deque<sax::Token>::iterator& input) const;
+	CSG parseCSG(std::deque<sax::Token>::iterator& input) const;
+	GNF parseGNF(std::deque<sax::Token>::iterator& input) const;
+	CNF parseCNF(std::deque<sax::Token>::iterator& input) const;
+	EpsilonFreeCFG parseEpsilonFreeCFG(std::deque<sax::Token>::iterator& input) const;
+	CFG parseCFG(std::deque<sax::Token>::iterator& input) const;
+	LG parseLG(std::deque<sax::Token>::iterator& input) const;
+	RightRG parseRightRG(std::deque<sax::Token>::iterator& input) const;
+	RightLG parseRightLG(std::deque<sax::Token>::iterator& input) const;
+	LeftRG parseLeftRG(std::deque<sax::Token>::iterator& input) const;
+	LeftLG parseLeftLG(std::deque<sax::Token>::iterator& input) const;
 
 	template<typename T> friend struct alib::xmlApi;
 public:
-	bool first(const std::deque<sax::Token>& input) const;
+	bool first(const std::deque<sax::Token>::const_iterator& input) const;
 };
 
 } /* namespace grammar */
diff --git a/alib2data/src/graph/GraphFromXMLParser.cpp b/alib2data/src/graph/GraphFromXMLParser.cpp
index c7ab41870e..0b08695ab1 100644
--- a/alib2data/src/graph/GraphFromXMLParser.cpp
+++ b/alib2data/src/graph/GraphFromXMLParser.cpp
@@ -5,7 +5,7 @@
 
 namespace graph {
 
-bool GraphFromXMLParser::first(const std::deque<sax::Token> &input) const
+bool GraphFromXMLParser::first(const std::deque<sax::Token>::const_iterator& input) const
 {
 	if (alib::xmlApi<DirectedGraph>::first(input)) {
 		return true;
@@ -14,7 +14,7 @@ bool GraphFromXMLParser::first(const std::deque<sax::Token> &input) const
 	return false;
 }
 
-Graph GraphFromXMLParser::parseGraph(std::deque<sax::Token> &input) const
+Graph GraphFromXMLParser::parseGraph(std::deque<sax::Token>::iterator& input) const
 {
 	if (alib::xmlApi<DirectedGraph>::first(input)) {
 		return Graph(parseDirectedGraph(input));
@@ -25,7 +25,7 @@ Graph GraphFromXMLParser::parseGraph(std::deque<sax::Token> &input) const
 	throw exception::AlibException();
 }
 
-DirectedGraph GraphFromXMLParser::parseDirectedGraph(std::deque<sax::Token> &input) const
+DirectedGraph GraphFromXMLParser::parseDirectedGraph(std::deque<sax::Token>::iterator& input) const
 {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAPH_DIRECTED_GRAPH);
 
@@ -39,7 +39,7 @@ DirectedGraph GraphFromXMLParser::parseDirectedGraph(std::deque<sax::Token> &inp
 	return graph;
 }
 
-UndirectedGraph GraphFromXMLParser::parseUndirectedGraph(std::deque<sax::Token> &input) const
+UndirectedGraph GraphFromXMLParser::parseUndirectedGraph(std::deque<sax::Token>::iterator& input) const
 {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAPH_UNDIRECTED_GRAPH);
 
@@ -53,7 +53,7 @@ UndirectedGraph GraphFromXMLParser::parseUndirectedGraph(std::deque<sax::Token>
 	return graph;
 }
 
-REPRESENTATION GraphFromXMLParser::parseRepresentation(std::deque<sax::Token> &input) const
+REPRESENTATION GraphFromXMLParser::parseRepresentation(std::deque<sax::Token>::iterator& input) const
 {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "representation");
 
@@ -63,7 +63,7 @@ REPRESENTATION GraphFromXMLParser::parseRepresentation(std::deque<sax::Token> &i
 	return r;
 }
 
-Node GraphFromXMLParser::parseNode(std::deque<sax::Token> &input) const
+Node GraphFromXMLParser::parseNode(std::deque<sax::Token>::iterator& input) const
 {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "node");
 
@@ -73,7 +73,7 @@ Node GraphFromXMLParser::parseNode(std::deque<sax::Token> &input) const
 	return n;
 }
 
-DirectedEdge GraphFromXMLParser::parseDirectedEdge(std::deque<sax::Token> &input) const
+DirectedEdge GraphFromXMLParser::parseDirectedEdge(std::deque<sax::Token>::iterator& input) const
 {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "edge");
 
@@ -91,7 +91,7 @@ DirectedEdge GraphFromXMLParser::parseDirectedEdge(std::deque<sax::Token> &input
 	return DirectedEdge(std::move(from), std::move(to), std::move(name));
 }
 
-UndirectedEdge GraphFromXMLParser::parseUndirectedEdge(std::deque<sax::Token> &input) const
+UndirectedEdge GraphFromXMLParser::parseUndirectedEdge(std::deque<sax::Token>::iterator& input) const
 {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "edge");
 
@@ -109,7 +109,7 @@ UndirectedEdge GraphFromXMLParser::parseUndirectedEdge(std::deque<sax::Token> &i
 	return UndirectedEdge(std::move(first), std::move(second), std::move(name));
 }
 
-int GraphFromXMLParser::parseValue(std::deque<sax::Token> &input) const
+int GraphFromXMLParser::parseValue(std::deque<sax::Token>::iterator& input) const
 {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "value");
 
@@ -120,7 +120,7 @@ int GraphFromXMLParser::parseValue(std::deque<sax::Token> &input) const
 }
 
 template<typename T>
-void GraphFromXMLParser::parseNodes(std::deque<sax::Token> &input, T &graph) const
+void GraphFromXMLParser::parseNodes(std::deque<sax::Token>::iterator& input, T &graph) const
 {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "nodes");
 
@@ -131,7 +131,7 @@ void GraphFromXMLParser::parseNodes(std::deque<sax::Token> &input, T &graph) con
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "nodes");
 }
 
-void GraphFromXMLParser::parseDirectedEdges(std::deque<sax::Token> &input, DirectedGraph &graph) const
+void GraphFromXMLParser::parseDirectedEdges(std::deque<sax::Token>::iterator& input, DirectedGraph &graph) const
 {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "edges");
 
@@ -142,7 +142,7 @@ void GraphFromXMLParser::parseDirectedEdges(std::deque<sax::Token> &input, Direc
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "edges");
 }
 
-void GraphFromXMLParser::parseUndirectedEdges(std::deque<sax::Token> &input, UndirectedGraph &graph) const
+void GraphFromXMLParser::parseUndirectedEdges(std::deque<sax::Token>::iterator& input, UndirectedGraph &graph) const
 {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "edges");
 
@@ -154,7 +154,7 @@ void GraphFromXMLParser::parseUndirectedEdges(std::deque<sax::Token> &input, Und
 }
 
 template<typename T>
-void GraphFromXMLParser::parseNodeValues(std::deque<sax::Token> &input, T &graph) const
+void GraphFromXMLParser::parseNodeValues(std::deque<sax::Token>::iterator& input, T &graph) const
 {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "nodevalues");
 
@@ -168,7 +168,7 @@ void GraphFromXMLParser::parseNodeValues(std::deque<sax::Token> &input, T &graph
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "nodevalues");
 }
 
-void GraphFromXMLParser::parseDirectedEdgeValues(std::deque<sax::Token> &input, DirectedGraph &graph) const
+void GraphFromXMLParser::parseDirectedEdgeValues(std::deque<sax::Token>::iterator& input, DirectedGraph &graph) const
 {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "edgevalues");
 
@@ -182,7 +182,7 @@ void GraphFromXMLParser::parseDirectedEdgeValues(std::deque<sax::Token> &input,
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "edgevalues");
 }
 
-void GraphFromXMLParser::parseUndirectedEdgeValues(std::deque<sax::Token> &input, UndirectedGraph &graph) const
+void GraphFromXMLParser::parseUndirectedEdgeValues(std::deque<sax::Token>::iterator& input, UndirectedGraph &graph) const
 {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "edgevalues");
 
diff --git a/alib2data/src/graph/GraphFromXMLParser.h b/alib2data/src/graph/GraphFromXMLParser.h
index 32077493dc..610212c26a 100644
--- a/alib2data/src/graph/GraphFromXMLParser.h
+++ b/alib2data/src/graph/GraphFromXMLParser.h
@@ -23,28 +23,28 @@ class GraphFromXMLParser : public sax::FromXMLParserHelper
 {
 public:
 	GraphFromXMLParser() {}
-	bool first(const std::deque<sax::Token> &input) const;
+	bool first(const std::deque<sax::Token>::const_iterator& input) const;
 
 private:
-	Graph parseGraph(std::deque<sax::Token> &input) const;
-	DirectedGraph parseDirectedGraph(std::deque<sax::Token> &input) const;
-	UndirectedGraph parseUndirectedGraph(std::deque<sax::Token> &input) const;
+	Graph parseGraph(std::deque<sax::Token>::iterator& input) const;
+	DirectedGraph parseDirectedGraph(std::deque<sax::Token>::iterator& input) const;
+	UndirectedGraph parseUndirectedGraph(std::deque<sax::Token>::iterator& input) const;
 
-	REPRESENTATION parseRepresentation(std::deque<sax::Token> &input) const;
-	Node parseNode(std::deque<sax::Token> &input) const;
-	DirectedEdge parseDirectedEdge(std::deque<sax::Token> &input) const;
-	UndirectedEdge parseUndirectedEdge(std::deque<sax::Token> &input) const;
-	int parseValue(std::deque<sax::Token> &input) const;
+	REPRESENTATION parseRepresentation(std::deque<sax::Token>::iterator& input) const;
+	Node parseNode(std::deque<sax::Token>::iterator& input) const;
+	DirectedEdge parseDirectedEdge(std::deque<sax::Token>::iterator& input) const;
+	UndirectedEdge parseUndirectedEdge(std::deque<sax::Token>::iterator& input) const;
+	int parseValue(std::deque<sax::Token>::iterator& input) const;
 
 	template<typename T>
-	void parseNodes(std::deque<sax::Token> &input, T &graph) const;
-	void parseDirectedEdges(std::deque<sax::Token> &input, DirectedGraph &graph) const;
-	void parseUndirectedEdges(std::deque<sax::Token> &input, UndirectedGraph &graph) const;
+	void parseNodes(std::deque<sax::Token>::iterator& input, T &graph) const;
+	void parseDirectedEdges(std::deque<sax::Token>::iterator& input, DirectedGraph &graph) const;
+	void parseUndirectedEdges(std::deque<sax::Token>::iterator& input, UndirectedGraph &graph) const;
 
 	template<typename T>
-	void parseNodeValues(std::deque<sax::Token> &input, T &graph) const;
-	void parseDirectedEdgeValues(std::deque<sax::Token> &input, DirectedGraph &graph) const;
-	void parseUndirectedEdgeValues(std::deque<sax::Token> &input, UndirectedGraph &graph) const;
+	void parseNodeValues(std::deque<sax::Token>::iterator& input, T &graph) const;
+	void parseDirectedEdgeValues(std::deque<sax::Token>::iterator& input, DirectedGraph &graph) const;
+	void parseUndirectedEdgeValues(std::deque<sax::Token>::iterator& input, UndirectedGraph &graph) const;
 
 	template<typename T> friend struct alib::xmlApi;
 };
diff --git a/alib2data/src/label/LabelFromXMLParser.cpp b/alib2data/src/label/LabelFromXMLParser.cpp
index f3e3e61566..92185e0a59 100644
--- a/alib2data/src/label/LabelFromXMLParser.cpp
+++ b/alib2data/src/label/LabelFromXMLParser.cpp
@@ -12,11 +12,11 @@
 
 namespace label {
 
-Label LabelFromXMLParser::parseLabel(std::deque<sax::Token>& input) const {
+Label LabelFromXMLParser::parseLabel(std::deque<sax::Token>::iterator& input) const {
 	return parseLabel(input, std::set<FEATURES>({FEATURES::PRIMITIVE, FEATURES::HEXAVIGESIMAL, FEATURES::OBJECT, FEATURES::LABEL_SET, FEATURES::LABEL_PAIR, FEATURES::UNIQUE_LABEL}));
 }
 
-Label LabelFromXMLParser::parseLabel(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const {
+Label LabelFromXMLParser::parseLabel(std::deque<sax::Token>::iterator& input, const std::set<FEATURES>& features) const {
 	if(alib::xmlApi<PrimitiveLabel>::first(input)) {
 		if(!features.count(FEATURES::PRIMITIVE)) throw exception::AlibException();
 		return Label(parsePrimitiveLabel(input));
@@ -36,11 +36,11 @@ Label LabelFromXMLParser::parseLabel(std::deque<sax::Token>& input, const std::s
 		if(!features.count(FEATURES::UNIQUE_LABEL)) throw exception::AlibException();
 		return Label(parseUniqueLabel(input));
 	} else {
-		throw sax::ParserException(sax::Token("PrimitiveLabel, HexavigesimalLabel, ObjectLabel, LabelSetLabel, LabelPairLabel, UniqueLabel", sax::Token::TokenType::START_ELEMENT), input.front());
+		throw sax::ParserException(sax::Token("PrimitiveLabel, HexavigesimalLabel, ObjectLabel, LabelSetLabel, LabelPairLabel, UniqueLabel", sax::Token::TokenType::START_ELEMENT), *input);
 	}
 }
 
-bool LabelFromXMLParser::first(const std::deque<sax::Token>& input) const {
+bool LabelFromXMLParser::first(const std::deque<sax::Token>::const_iterator& input) const {
 	if(alib::xmlApi<PrimitiveLabel>::first(input) || alib::xmlApi<ObjectLabel>::first(input) || alib::xmlApi<LabelSetLabel>::first(input) || alib::xmlApi<LabelPairLabel>::first(input)) {
 		return true;
 	} else {
@@ -48,28 +48,28 @@ bool LabelFromXMLParser::first(const std::deque<sax::Token>& input) const {
 	}
 }
 
-PrimitiveLabel LabelFromXMLParser::parsePrimitiveLabel(std::deque<sax::Token>& input) const {
+PrimitiveLabel LabelFromXMLParser::parsePrimitiveLabel(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::LABEL_PRIMITIVE_LABEL);
 	PrimitiveLabel data(alib::xmlApi<primitive::Primitive>::parse(input));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::LABEL_PRIMITIVE_LABEL);
 	return data;
 }
 
-HexavigesimalLabel LabelFromXMLParser::parseHexavigesimalLabel(std::deque<sax::Token>& input) const {
+HexavigesimalLabel LabelFromXMLParser::parseHexavigesimalLabel(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::LABEL_HEXAVIGESIMAL_LABEL);
 	HexavigesimalLabel data(std::stoi(popTokenData(input, sax::Token::TokenType::CHARACTER)));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::LABEL_HEXAVIGESIMAL_LABEL);
 	return data;
 }
 
-ObjectLabel LabelFromXMLParser::parseObjectLabel(std::deque<sax::Token>& input) const {
+ObjectLabel LabelFromXMLParser::parseObjectLabel(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::LABEL_OBJECT_LABEL);
 	ObjectLabel data(alib::xmlApi<alib::Object>::parse(input));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::LABEL_OBJECT_LABEL);
 	return data;
 }
 
-LabelSetLabel LabelFromXMLParser::parseLabelSetLabel(std::deque<sax::Token>& input) const {
+LabelSetLabel LabelFromXMLParser::parseLabelSetLabel(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::LABEL_LABEL_SET_LABEL);
 	std::set<Label> labels;
 	while(isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -80,7 +80,7 @@ LabelSetLabel LabelFromXMLParser::parseLabelSetLabel(std::deque<sax::Token>& inp
 	return data;
 }
 
-LabelPairLabel LabelFromXMLParser::parseLabelPairLabel(std::deque<sax::Token>& input) const {
+LabelPairLabel LabelFromXMLParser::parseLabelPairLabel(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::LABEL_LABEL_PAIR_LABEL);
 
 	Label firstLabel = parseLabel(input);
@@ -91,7 +91,7 @@ LabelPairLabel LabelFromXMLParser::parseLabelPairLabel(std::deque<sax::Token>& i
 	return data;
 }
 
-UniqueLabel LabelFromXMLParser::parseUniqueLabel(std::deque<sax::Token>& input) const {
+UniqueLabel LabelFromXMLParser::parseUniqueLabel(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::LABEL_UNIQUE_LABEL);
 
 	Label firstLabel = parseLabel(input);
diff --git a/alib2data/src/label/LabelFromXMLParser.h b/alib2data/src/label/LabelFromXMLParser.h
index 8b3fba646e..755db973f7 100644
--- a/alib2data/src/label/LabelFromXMLParser.h
+++ b/alib2data/src/label/LabelFromXMLParser.h
@@ -38,19 +38,19 @@ public:
 	LabelFromXMLParser() {}
 
 private:
-	Label parseLabel(std::deque<sax::Token>& input, const std::set<FEATURES>&) const;
-	Label parseLabel(std::deque<sax::Token>& input) const;
+	Label parseLabel(std::deque<sax::Token>::iterator& input, const std::set<FEATURES>&) const;
+	Label parseLabel(std::deque<sax::Token>::iterator& input) const;
 
-	PrimitiveLabel parsePrimitiveLabel(std::deque<sax::Token>& input) const;
-	HexavigesimalLabel parseHexavigesimalLabel(std::deque<sax::Token>& input) const;
-	ObjectLabel parseObjectLabel(std::deque<sax::Token>& input) const;
-	LabelSetLabel parseLabelSetLabel(std::deque<sax::Token>& input) const;
-	LabelPairLabel parseLabelPairLabel(std::deque<sax::Token>& input) const;
-	UniqueLabel parseUniqueLabel(std::deque<sax::Token>& input) const;
+	PrimitiveLabel parsePrimitiveLabel(std::deque<sax::Token>::iterator& input) const;
+	HexavigesimalLabel parseHexavigesimalLabel(std::deque<sax::Token>::iterator& input) const;
+	ObjectLabel parseObjectLabel(std::deque<sax::Token>::iterator& input) const;
+	LabelSetLabel parseLabelSetLabel(std::deque<sax::Token>::iterator& input) const;
+	LabelPairLabel parseLabelPairLabel(std::deque<sax::Token>::iterator& input) const;
+	UniqueLabel parseUniqueLabel(std::deque<sax::Token>::iterator& input) const;
 
 	template<typename T> friend struct alib::xmlApi;
 public:
-	bool first(const std::deque<sax::Token>& input) const;
+	bool first(const std::deque<sax::Token>::const_iterator& input) const;
 };
 
 } /* namespace label */
diff --git a/alib2data/src/object/ObjectFromXMLParser.cpp b/alib2data/src/object/ObjectFromXMLParser.cpp
index e397829b16..c6b7b3177d 100644
--- a/alib2data/src/object/ObjectFromXMLParser.cpp
+++ b/alib2data/src/object/ObjectFromXMLParser.cpp
@@ -14,7 +14,7 @@
 
 namespace alib {
 
-Object ObjectFromXMLParser::parseObject(std::deque<sax::Token>& input) const {
+Object ObjectFromXMLParser::parseObject(std::deque<sax::Token>::iterator& input) const {
 	if(alib::FromXMLParsers::symbolParser.first(input)) {
 		alphabet::Symbol symbol = alib::xmlApi<alphabet::Symbol>::parse(input);
 		Object res(std::move(symbol.getData()));
@@ -63,14 +63,14 @@ Object ObjectFromXMLParser::parseObject(std::deque<sax::Token>& input) const {
 	}
 }
 
-Void ObjectFromXMLParser::parseVoid(std::deque<sax::Token>& input) const {
+Void ObjectFromXMLParser::parseVoid(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALIB_VOID);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALIB_VOID);
 
 	return Void {};
 }
 
-bool ObjectFromXMLParser::first(const std::deque<sax::Token>& input) const {
+bool ObjectFromXMLParser::first(const std::deque<sax::Token>::const_iterator& input) const {
 	return alib::FromXMLParsers::symbolParser.first(input) || alib::FromXMLParsers::exceptionParser.first(input) || alib::FromXMLParsers::labelParser.first(input) || alib::FromXMLParsers::regexpParser.first(input) || alib::FromXMLParsers::stringParser.first(input) || alib::FromXMLParsers::automatonParser.first(input) || alib::FromXMLParsers::grammarParser.first(input) || alib::FromXMLParsers::containerParser.first(input) || alib::xmlApi<Void>::first(input);
 }
 
diff --git a/alib2data/src/object/ObjectFromXMLParser.h b/alib2data/src/object/ObjectFromXMLParser.h
index c50f304615..f7f8e92d6f 100644
--- a/alib2data/src/object/ObjectFromXMLParser.h
+++ b/alib2data/src/object/ObjectFromXMLParser.h
@@ -31,12 +31,12 @@ public:
 	ObjectFromXMLParser() {}
 
 private:
-	Object parseObject(std::deque<sax::Token>& input) const;
-	Void parseVoid(std::deque<sax::Token>& input) const;
+	Object parseObject(std::deque<sax::Token>::iterator& input) const;
+	Void parseVoid(std::deque<sax::Token>::iterator& input) const;
 
 	template<typename T> friend struct alib::xmlApi;
 public:
-	bool first(const std::deque<sax::Token>& input) const;
+	bool first(const std::deque<sax::Token>::const_iterator& input) const;
 };
 
 } /* namespace alib */
diff --git a/alib2data/src/primitive/PrimitiveFromXMLParser.cpp b/alib2data/src/primitive/PrimitiveFromXMLParser.cpp
index e95ef5e99a..a0e46cc877 100644
--- a/alib2data/src/primitive/PrimitiveFromXMLParser.cpp
+++ b/alib2data/src/primitive/PrimitiveFromXMLParser.cpp
@@ -14,11 +14,11 @@
 
 namespace primitive {
 
-Primitive PrimitiveFromXMLParser::parsePrimitive(std::deque<sax::Token>& input) const {
+Primitive PrimitiveFromXMLParser::parsePrimitive(std::deque<sax::Token>::iterator& input) const {
 	return parsePrimitive(input, std::set<FEATURES>({FEATURES::STRING, FEATURES::CHAR, FEATURES::INTEGER, FEATURES::UNSIGNED, FEATURES::BOOL}));
 }
 
-Primitive PrimitiveFromXMLParser::parsePrimitive(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const {
+Primitive PrimitiveFromXMLParser::parsePrimitive(std::deque<sax::Token>::iterator& input, const std::set<FEATURES>& features) const {
 	if(alib::xmlApi<Integer>::first(input)) {
 		if(!features.count(FEATURES::INTEGER)) throw exception::AlibException();
 		return Primitive(parseInteger(input));
@@ -35,11 +35,11 @@ Primitive PrimitiveFromXMLParser::parsePrimitive(std::deque<sax::Token>& input,
 		if(!features.count(FEATURES::BOOL)) throw exception::AlibException();
 		return Primitive(parseBool(input));
 	} else {
-		throw sax::ParserException(sax::Token("Integer, String, Character, Unsigned, Bool", sax::Token::TokenType::START_ELEMENT), input.front());
+		throw sax::ParserException(sax::Token("Integer, String, Character, Unsigned, Bool", sax::Token::TokenType::START_ELEMENT), *input);
 	}
 }
 
-bool PrimitiveFromXMLParser::first(const std::deque<sax::Token>& input) const {
+bool PrimitiveFromXMLParser::first(const std::deque<sax::Token>::const_iterator& input) const {
 	if(alib::xmlApi<Integer>::first(input) || alib::xmlApi<String>::first(input) || alib::xmlApi<Character>::first(input) || alib::xmlApi<Unsigned>::first(input) || alib::xmlApi<Bool>::first(input)) {
 		return true;
 	} else {
@@ -47,21 +47,21 @@ bool PrimitiveFromXMLParser::first(const std::deque<sax::Token>& input) const {
 	}
 }
 
-Integer PrimitiveFromXMLParser::parseInteger(std::deque<sax::Token>& input) const {
+Integer PrimitiveFromXMLParser::parseInteger(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::PRIMITIVE_INTEGER);
 	Integer data(std::stoi(popTokenData(input, sax::Token::TokenType::CHARACTER)));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::PRIMITIVE_INTEGER);
 	return data;
 }
 
-Character PrimitiveFromXMLParser::parseCharacter(std::deque<sax::Token>& input) const {
+Character PrimitiveFromXMLParser::parseCharacter(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::PRIMITIVE_CHARACTER);
 	Character data(popTokenData(input, sax::Token::TokenType::CHARACTER)[0]);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::PRIMITIVE_CHARACTER);
 	return data;
 }
 
-String PrimitiveFromXMLParser::parseString(std::deque<sax::Token>& input) const {
+String PrimitiveFromXMLParser::parseString(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::PRIMITIVE_STRING);
 	std::string data = "";
 	if( isTokenType(input, sax::Token::TokenType::CHARACTER))
@@ -70,14 +70,14 @@ String PrimitiveFromXMLParser::parseString(std::deque<sax::Token>& input) const
 	return String(std::move(data));
 }
 
-Unsigned PrimitiveFromXMLParser::parseUnsigned(std::deque<sax::Token>& input) const {
+Unsigned PrimitiveFromXMLParser::parseUnsigned(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::PRIMITIVE_UNSIGNED);
 	Unsigned data(std::stou(popTokenData(input, sax::Token::TokenType::CHARACTER)));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::PRIMITIVE_UNSIGNED);
 	return data;
 }
 
-Bool PrimitiveFromXMLParser::parseBool(std::deque<sax::Token>& input) const {
+Bool PrimitiveFromXMLParser::parseBool(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::PRIMITIVE_BOOL);
 	std::string tmp = popTokenData(input, sax::Token::TokenType::CHARACTER);
 	bool data;
@@ -91,35 +91,35 @@ Bool PrimitiveFromXMLParser::parseBool(std::deque<sax::Token>& input) const {
 	return Bool(data);
 }
 
-int PrimitiveFromXMLParser::parseIntegerRaw(std::deque<sax::Token>& input) const {
+int PrimitiveFromXMLParser::parseIntegerRaw(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::PRIMITIVE_INTEGER);
 	int data = std::stoi(popTokenData(input, sax::Token::TokenType::CHARACTER));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::PRIMITIVE_INTEGER);
 	return data;
 }
 
-char PrimitiveFromXMLParser::parseCharacterRaw(std::deque<sax::Token>& input) const {
+char PrimitiveFromXMLParser::parseCharacterRaw(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::PRIMITIVE_CHARACTER);
 	char data = popTokenData(input, sax::Token::TokenType::CHARACTER)[0];
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::PRIMITIVE_CHARACTER);
 	return data;
 }
 
-std::string PrimitiveFromXMLParser::parseStringRaw(std::deque<sax::Token>& input) const {
+std::string PrimitiveFromXMLParser::parseStringRaw(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::PRIMITIVE_STRING);
 	std::string data = popTokenData(input, sax::Token::TokenType::CHARACTER);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::PRIMITIVE_STRING);
 	return data;
 }
 
-unsigned PrimitiveFromXMLParser::parseUnsignedRaw(std::deque<sax::Token>& input) const {
+unsigned PrimitiveFromXMLParser::parseUnsignedRaw(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::PRIMITIVE_UNSIGNED);
 	unsigned data = std::stou(popTokenData(input, sax::Token::TokenType::CHARACTER));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::PRIMITIVE_UNSIGNED);
 	return data;
 }
 
-bool PrimitiveFromXMLParser::parseBoolRaw(std::deque<sax::Token>& input) const {
+bool PrimitiveFromXMLParser::parseBoolRaw(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::PRIMITIVE_BOOL);
 	std::string tmp = popTokenData(input, sax::Token::TokenType::CHARACTER);
 	bool data;
diff --git a/alib2data/src/primitive/PrimitiveFromXMLParser.h b/alib2data/src/primitive/PrimitiveFromXMLParser.h
index 4a0056cc21..6c06cca3d9 100644
--- a/alib2data/src/primitive/PrimitiveFromXMLParser.h
+++ b/alib2data/src/primitive/PrimitiveFromXMLParser.h
@@ -36,24 +36,24 @@ public:
 	PrimitiveFromXMLParser() {}
 
 private:
-	Primitive parsePrimitive(std::deque<sax::Token>& input, const std::set<FEATURES>&) const;
-	Primitive parsePrimitive(std::deque<sax::Token>& input) const;
+	Primitive parsePrimitive(std::deque<sax::Token>::iterator& input, const std::set<FEATURES>&) const;
+	Primitive parsePrimitive(std::deque<sax::Token>::iterator& input) const;
 
-	Integer parseInteger(std::deque<sax::Token>& input) const;
-	Character parseCharacter(std::deque<sax::Token>& input) const;
-	String parseString(std::deque<sax::Token>& input) const;
-	Unsigned parseUnsigned(std::deque<sax::Token>& input) const;
-	Bool parseBool(std::deque<sax::Token>& input) const;
+	Integer parseInteger(std::deque<sax::Token>::iterator& input) const;
+	Character parseCharacter(std::deque<sax::Token>::iterator& input) const;
+	String parseString(std::deque<sax::Token>::iterator& input) const;
+	Unsigned parseUnsigned(std::deque<sax::Token>::iterator& input) const;
+	Bool parseBool(std::deque<sax::Token>::iterator& input) const;
 
-	int parseIntegerRaw(std::deque<sax::Token>& input) const;
-	char parseCharacterRaw(std::deque<sax::Token>& input) const;
-	std::string parseStringRaw(std::deque<sax::Token>& input) const;
-	unsigned parseUnsignedRaw(std::deque<sax::Token>& input) const;
-	bool parseBoolRaw(std::deque<sax::Token>& input) const;
+	int parseIntegerRaw(std::deque<sax::Token>::iterator& input) const;
+	char parseCharacterRaw(std::deque<sax::Token>::iterator& input) const;
+	std::string parseStringRaw(std::deque<sax::Token>::iterator& input) const;
+	unsigned parseUnsignedRaw(std::deque<sax::Token>::iterator& input) const;
+	bool parseBoolRaw(std::deque<sax::Token>::iterator& input) const;
 
 	template<typename T> friend struct alib::xmlApi;
 public:
-	bool first(const std::deque<sax::Token>& input) const;
+	bool first(const std::deque<sax::Token>::const_iterator& input) const;
 };
 
 } /* namespace primitive */
diff --git a/alib2data/src/regexp/RegExpFromXMLParser.cpp b/alib2data/src/regexp/RegExpFromXMLParser.cpp
index 9d17ba2a88..73462bd934 100644
--- a/alib2data/src/regexp/RegExpFromXMLParser.cpp
+++ b/alib2data/src/regexp/RegExpFromXMLParser.cpp
@@ -12,11 +12,11 @@
 
 namespace regexp {
 
-RegExp RegExpFromXMLParser::parseRegExp(std::deque<sax::Token>& input) const {
+RegExp RegExpFromXMLParser::parseRegExp(std::deque<sax::Token>::iterator& input) const {
 	return parseRegExp(input, std::set<FEATURES>({FEATURES::FORMAL, FEATURES::UNBOUNDED}));
 }
 
-RegExp RegExpFromXMLParser::parseRegExp(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const {
+RegExp RegExpFromXMLParser::parseRegExp(std::deque<sax::Token>::iterator& input, const std::set<FEATURES>& features) const {
 	if(alib::xmlApi<UnboundedRegExp>::first(input)) {
 		if(!features.count(FEATURES::UNBOUNDED)) throw exception::AlibException();
 		return RegExp(parseUnboundedRegExp(input));
@@ -27,7 +27,7 @@ RegExp RegExpFromXMLParser::parseRegExp(std::deque<sax::Token>& input, const std
 	throw exception::AlibException();
 }
 
-bool RegExpFromXMLParser::first(const std::deque<sax::Token>& input) const {
+bool RegExpFromXMLParser::first(const std::deque<sax::Token>::const_iterator& input) const {
 	if(alib::xmlApi<UnboundedRegExp>::first(input) || alib::xmlApi<FormalRegExp>::first(input)) {
 		return true;
 	} else {
@@ -35,7 +35,7 @@ bool RegExpFromXMLParser::first(const std::deque<sax::Token>& input) const {
 	}
 }
 
-UnboundedRegExp RegExpFromXMLParser::parseUnboundedRegExp(std::deque<sax::Token>& input) const {
+UnboundedRegExp RegExpFromXMLParser::parseUnboundedRegExp(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::REGEXP_UNBOUNDED_REGEXP);
 
 	UnboundedRegExp regexp;
@@ -49,7 +49,7 @@ UnboundedRegExp RegExpFromXMLParser::parseUnboundedRegExp(std::deque<sax::Token>
 	return regexp;
 }
 
-FormalRegExp RegExpFromXMLParser::parseFormalRegExp(std::deque<sax::Token>& input) const {
+FormalRegExp RegExpFromXMLParser::parseFormalRegExp(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::REGEXP_FORMAL_REGEXP);
 
 	FormalRegExp regexp;
@@ -63,7 +63,7 @@ FormalRegExp RegExpFromXMLParser::parseFormalRegExp(std::deque<sax::Token>& inpu
 	return regexp;
 }
 
-void RegExpFromXMLParser::parseAlphabet(std::deque<sax::Token> &input, UnboundedRegExp& regexp) const {
+void RegExpFromXMLParser::parseAlphabet(std::deque<sax::Token>::iterator& input, UnboundedRegExp& regexp) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "alphabet");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
 		regexp.addSymbolToAlphabet(alib::xmlApi<alphabet::Symbol>::parse(input));
@@ -71,7 +71,7 @@ void RegExpFromXMLParser::parseAlphabet(std::deque<sax::Token> &input, Unbounded
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "alphabet");
 }
 
-void RegExpFromXMLParser::parseAlphabet(std::deque<sax::Token> &input, FormalRegExp& regexp) const {
+void RegExpFromXMLParser::parseAlphabet(std::deque<sax::Token>::iterator& input, FormalRegExp& regexp) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "alphabet");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
 		regexp.addSymbolToAlphabet(alib::xmlApi<alphabet::Symbol>::parse(input));
@@ -79,7 +79,7 @@ void RegExpFromXMLParser::parseAlphabet(std::deque<sax::Token> &input, FormalReg
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "alphabet");
 }
 
-UnboundedRegExpElement* RegExpFromXMLParser::parseUnboundedRegExpElement(std::deque<sax::Token>& input) const {
+UnboundedRegExpElement* RegExpFromXMLParser::parseUnboundedRegExpElement(std::deque<sax::Token>::iterator& input) const {
 	if (isToken(input, sax::Token::TokenType::START_ELEMENT, "empty")) {
 		return parseUnboundedRegExpEmpty(input);
 	} else if (isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
@@ -95,7 +95,7 @@ UnboundedRegExpElement* RegExpFromXMLParser::parseUnboundedRegExpElement(std::de
 	}
 }
 
-UnboundedRegExpAlternation* RegExpFromXMLParser::parseUnboundedRegExpAlternation(std::deque<sax::Token>& input) const {
+UnboundedRegExpAlternation* RegExpFromXMLParser::parseUnboundedRegExpAlternation(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "alternation");
 
 	UnboundedRegExpAlternation* alternation = new UnboundedRegExpAlternation();
@@ -110,7 +110,7 @@ UnboundedRegExpAlternation* RegExpFromXMLParser::parseUnboundedRegExpAlternation
 	return alternation;
 }
 
-UnboundedRegExpConcatenation* RegExpFromXMLParser::parseUnboundedRegExpConcatenation(std::deque<sax::Token>& input) const {
+UnboundedRegExpConcatenation* RegExpFromXMLParser::parseUnboundedRegExpConcatenation(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "concatenation");
 
 	UnboundedRegExpConcatenation* concatenation = new UnboundedRegExpConcatenation();
@@ -126,7 +126,7 @@ UnboundedRegExpConcatenation* RegExpFromXMLParser::parseUnboundedRegExpConcatena
 
 }
 
-UnboundedRegExpIteration* RegExpFromXMLParser::parseUnboundedRegExpIteration(std::deque<sax::Token>& input) const {
+UnboundedRegExpIteration* RegExpFromXMLParser::parseUnboundedRegExpIteration(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "iteration");
 
 	UnboundedRegExpElement* element = parseUnboundedRegExpElement(input);
@@ -137,7 +137,7 @@ UnboundedRegExpIteration* RegExpFromXMLParser::parseUnboundedRegExpIteration(std
 	return iteration;
 }
 
-UnboundedRegExpEpsilon* RegExpFromXMLParser::parseUnboundedRegExpEpsilon(std::deque<sax::Token>& input) const {
+UnboundedRegExpEpsilon* RegExpFromXMLParser::parseUnboundedRegExpEpsilon(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon");
 
 	UnboundedRegExpEpsilon* epsilon = new UnboundedRegExpEpsilon();
@@ -146,7 +146,7 @@ UnboundedRegExpEpsilon* RegExpFromXMLParser::parseUnboundedRegExpEpsilon(std::de
 	return epsilon;
 }
 
-UnboundedRegExpEmpty* RegExpFromXMLParser::parseUnboundedRegExpEmpty(std::deque<sax::Token>& input) const {
+UnboundedRegExpEmpty* RegExpFromXMLParser::parseUnboundedRegExpEmpty(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "empty");
 
 	UnboundedRegExpEmpty* empty = new UnboundedRegExpEmpty();
@@ -155,7 +155,7 @@ UnboundedRegExpEmpty* RegExpFromXMLParser::parseUnboundedRegExpEmpty(std::deque<
 	return empty;
 }
 
-FormalRegExpElement* RegExpFromXMLParser::parseFormalRegExpElement(std::deque<sax::Token>& input) const {
+FormalRegExpElement* RegExpFromXMLParser::parseFormalRegExpElement(std::deque<sax::Token>::iterator& input) const {
 	if (isToken(input, sax::Token::TokenType::START_ELEMENT, "empty")) {
 		return parseFormalRegExpEmpty(input);
 	} else if (isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
@@ -171,7 +171,7 @@ FormalRegExpElement* RegExpFromXMLParser::parseFormalRegExpElement(std::deque<sa
 	}
 }
 
-FormalRegExpAlternation* RegExpFromXMLParser::parseFormalRegExpAlternation(std::deque<sax::Token>& input) const {
+FormalRegExpAlternation* RegExpFromXMLParser::parseFormalRegExpAlternation(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "alternation");
 
 	FormalRegExpElement* element1 = parseFormalRegExpElement(input);
@@ -186,7 +186,7 @@ FormalRegExpAlternation* RegExpFromXMLParser::parseFormalRegExpAlternation(std::
 	return alternation;
 }
 
-FormalRegExpConcatenation* RegExpFromXMLParser::parseFormalRegExpConcatenation(std::deque<sax::Token>& input) const {
+FormalRegExpConcatenation* RegExpFromXMLParser::parseFormalRegExpConcatenation(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "concatenation");
 
 	FormalRegExpElement* element1 = parseFormalRegExpElement(input);
@@ -202,7 +202,7 @@ FormalRegExpConcatenation* RegExpFromXMLParser::parseFormalRegExpConcatenation(s
 
 }
 
-FormalRegExpIteration* RegExpFromXMLParser::parseFormalRegExpIteration(std::deque<sax::Token>& input) const {
+FormalRegExpIteration* RegExpFromXMLParser::parseFormalRegExpIteration(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "iteration");
 
 	FormalRegExpElement* element = parseFormalRegExpElement(input);
@@ -213,7 +213,7 @@ FormalRegExpIteration* RegExpFromXMLParser::parseFormalRegExpIteration(std::dequ
 	return iteration;
 }
 
-FormalRegExpEpsilon* RegExpFromXMLParser::parseFormalRegExpEpsilon(std::deque<sax::Token>& input) const {
+FormalRegExpEpsilon* RegExpFromXMLParser::parseFormalRegExpEpsilon(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon");
 
 	FormalRegExpEpsilon* epsilon = new FormalRegExpEpsilon();
@@ -222,7 +222,7 @@ FormalRegExpEpsilon* RegExpFromXMLParser::parseFormalRegExpEpsilon(std::deque<sa
 	return epsilon;
 }
 
-FormalRegExpEmpty* RegExpFromXMLParser::parseFormalRegExpEmpty(std::deque<sax::Token>& input) const {
+FormalRegExpEmpty* RegExpFromXMLParser::parseFormalRegExpEmpty(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "empty");
 
 	FormalRegExpEmpty* empty = new FormalRegExpEmpty();
diff --git a/alib2data/src/regexp/RegExpFromXMLParser.h b/alib2data/src/regexp/RegExpFromXMLParser.h
index 2ffc4e8660..16811c9b90 100644
--- a/alib2data/src/regexp/RegExpFromXMLParser.h
+++ b/alib2data/src/regexp/RegExpFromXMLParser.h
@@ -35,34 +35,34 @@ public:
 	RegExpFromXMLParser() {}
 
 private:
-	void parseAlphabet(std::deque<sax::Token>& input, UnboundedRegExp& regexp) const;
-	void parseAlphabet(std::deque<sax::Token>& input, FormalRegExp& regexp) const;
+	void parseAlphabet(std::deque<sax::Token>::iterator& input, UnboundedRegExp& regexp) const;
+	void parseAlphabet(std::deque<sax::Token>::iterator& input, FormalRegExp& regexp) const;
 
-	UnboundedRegExpElement* parseUnboundedRegExpElement(std::deque<sax::Token>& input) const;
+	UnboundedRegExpElement* parseUnboundedRegExpElement(std::deque<sax::Token>::iterator& input) const;
 
-	UnboundedRegExpEpsilon* parseUnboundedRegExpEpsilon(std::deque<sax::Token>& input) const;
-	UnboundedRegExpEmpty* parseUnboundedRegExpEmpty(std::deque<sax::Token>& input) const;
-	UnboundedRegExpIteration* parseUnboundedRegExpIteration(std::deque<sax::Token> &input) const;
-	UnboundedRegExpAlternation* parseUnboundedRegExpAlternation(std::deque<sax::Token> &input) const;
-	UnboundedRegExpConcatenation* parseUnboundedRegExpConcatenation(std::deque<sax::Token> &input) const;
+	UnboundedRegExpEpsilon* parseUnboundedRegExpEpsilon(std::deque<sax::Token>::iterator& input) const;
+	UnboundedRegExpEmpty* parseUnboundedRegExpEmpty(std::deque<sax::Token>::iterator& input) const;
+	UnboundedRegExpIteration* parseUnboundedRegExpIteration(std::deque<sax::Token>::iterator& input) const;
+	UnboundedRegExpAlternation* parseUnboundedRegExpAlternation(std::deque<sax::Token>::iterator& input) const;
+	UnboundedRegExpConcatenation* parseUnboundedRegExpConcatenation(std::deque<sax::Token>::iterator& input) const;
 
-	FormalRegExpElement* parseFormalRegExpElement(std::deque<sax::Token>& input) const;
+	FormalRegExpElement* parseFormalRegExpElement(std::deque<sax::Token>::iterator& input) const;
 
-	FormalRegExpEpsilon* parseFormalRegExpEpsilon(std::deque<sax::Token>& input) const;
-	FormalRegExpEmpty* parseFormalRegExpEmpty(std::deque<sax::Token>& input) const;
-	FormalRegExpIteration* parseFormalRegExpIteration(std::deque<sax::Token> &input) const;
-	FormalRegExpAlternation* parseFormalRegExpAlternation(std::deque<sax::Token> &input) const;
-	FormalRegExpConcatenation* parseFormalRegExpConcatenation(std::deque<sax::Token> &input) const;
+	FormalRegExpEpsilon* parseFormalRegExpEpsilon(std::deque<sax::Token>::iterator& input) const;
+	FormalRegExpEmpty* parseFormalRegExpEmpty(std::deque<sax::Token>::iterator& input) const;
+	FormalRegExpIteration* parseFormalRegExpIteration(std::deque<sax::Token>::iterator& input) const;
+	FormalRegExpAlternation* parseFormalRegExpAlternation(std::deque<sax::Token>::iterator& input) const;
+	FormalRegExpConcatenation* parseFormalRegExpConcatenation(std::deque<sax::Token>::iterator& input) const;
 
-	RegExp parseRegExp(std::deque<sax::Token>& input) const;
-	RegExp parseRegExp(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const;
+	RegExp parseRegExp(std::deque<sax::Token>::iterator& input) const;
+	RegExp parseRegExp(std::deque<sax::Token>::iterator& input, const std::set<FEATURES>& features) const;
 
-	UnboundedRegExp parseUnboundedRegExp(std::deque<sax::Token>& input) const;
-	FormalRegExp parseFormalRegExp(std::deque<sax::Token>& input) const;
+	UnboundedRegExp parseUnboundedRegExp(std::deque<sax::Token>::iterator& input) const;
+	FormalRegExp parseFormalRegExp(std::deque<sax::Token>::iterator& input) const;
 
 	template<typename T> friend struct alib::xmlApi;
 public:
-	bool first(const std::deque<sax::Token>& input) const;
+	bool first(const std::deque<sax::Token>::const_iterator& input) const;
 };
 
 } /* namespace regexp */
diff --git a/alib2data/src/sax/FromXMLParserHelper.cpp b/alib2data/src/sax/FromXMLParserHelper.cpp
index 9622f077af..c4708b0abb 100644
--- a/alib2data/src/sax/FromXMLParserHelper.cpp
+++ b/alib2data/src/sax/FromXMLParserHelper.cpp
@@ -10,29 +10,29 @@
 
 namespace sax {
 
-bool FromXMLParserHelper::isToken(const std::deque<Token>& input, Token::TokenType type, const std::string& data) {
-	return input.front().getType() == type && input.front().getData() == data;
+bool FromXMLParserHelper::isToken(const std::deque<Token>::const_iterator& input, Token::TokenType type, const std::string& data) {
+	return input->getType() == type && input->getData() == data;
 }
 
-bool FromXMLParserHelper::isTokenType(const std::deque<Token>& input, Token::TokenType type) {
-	return input.front().getType() == type;
+bool FromXMLParserHelper::isTokenType(const std::deque<Token>::const_iterator& input, Token::TokenType type) {
+	return input->getType() == type;
 }
 
-void FromXMLParserHelper::popToken(std::deque<Token>& input, Token::TokenType type, const std::string& data) {
+void FromXMLParserHelper::popToken(std::deque<Token>::iterator& input, Token::TokenType type, const std::string& data) {
 	if (isToken(input, type, data)) {
-		input.pop_front();
+		input++;
 	} else {
-		throw ParserException(Token(data, type), input.front());
+		throw ParserException(Token(data, type), *input);
 	}
 }
 
-std::string FromXMLParserHelper::popTokenData(std::deque<Token>& input, Token::TokenType type) {
+std::string FromXMLParserHelper::popTokenData(std::deque<Token>::iterator& input, Token::TokenType type) {
 	if(isTokenType(input, type)) {
-		std::string result = std::move(input.front()).getDataMove();
-		input.pop_front();
-		return std::move(result);
+		std::string result = std::move(*input).moveData();
+		input++;
+		return result;
 	} else {
-		throw ParserException(Token("?", type), input.front());
+		throw ParserException(Token("?", type), *input);
 	}
 }
 
diff --git a/alib2data/src/sax/FromXMLParserHelper.h b/alib2data/src/sax/FromXMLParserHelper.h
index 0813ba180b..e27d06852f 100644
--- a/alib2data/src/sax/FromXMLParserHelper.h
+++ b/alib2data/src/sax/FromXMLParserHelper.h
@@ -18,10 +18,10 @@ namespace sax {
  */
 class FromXMLParserHelper {
 public:
-	static bool isToken(const std::deque<Token>& input, Token::TokenType type, const std::string& data);
-	static bool isTokenType(const std::deque<Token>& input, Token::TokenType type);
-	static void popToken(std::deque<Token>& input, Token::TokenType type, const std::string& data);
-	static std::string popTokenData(std::deque<Token>& input, Token::TokenType type);
+	static bool isToken(const std::deque<Token>::const_iterator& input, Token::TokenType type, const std::string& data);
+	static bool isTokenType(const std::deque<Token>::const_iterator& input, Token::TokenType type);
+	static void popToken(std::deque<Token>::iterator& input, Token::TokenType type, const std::string& data);
+	static std::string popTokenData(std::deque<Token>::iterator& input, Token::TokenType type);
 
 };
 
diff --git a/alib2data/src/sax/Token.cpp b/alib2data/src/sax/Token.cpp
index 438783d986..7ab6eeac24 100644
--- a/alib2data/src/sax/Token.cpp
+++ b/alib2data/src/sax/Token.cpp
@@ -25,7 +25,7 @@ const std::string& Token::getData() const {
 	return data;
 }
 
-std::string&& Token::getDataMove() && {
+std::string&& Token::moveData() && {
 	return std::move(data);
 }
 
diff --git a/alib2data/src/sax/Token.h b/alib2data/src/sax/Token.h
index d6f455ebac..9d85e119ba 100644
--- a/alib2data/src/sax/Token.h
+++ b/alib2data/src/sax/Token.h
@@ -40,7 +40,7 @@ public:
 	/**
 	 * @return name of the tag or characters read
 	 */
-	std::string&& getDataMove() &&; //TODO should be named getData only
+	std::string&& moveData() &&; //TODO should be named getData only
 
 	/**
 	 * @return type of the token - star of the tag, end of the tag, attribute
diff --git a/alib2data/src/string/StringFromXMLParser.cpp b/alib2data/src/string/StringFromXMLParser.cpp
index 62a8716dfb..a4a9cdd6b7 100644
--- a/alib2data/src/string/StringFromXMLParser.cpp
+++ b/alib2data/src/string/StringFromXMLParser.cpp
@@ -12,11 +12,11 @@
 
 namespace string {
 
-String StringFromXMLParser::parseString(std::deque<sax::Token>& input) const {
+String StringFromXMLParser::parseString(std::deque<sax::Token>::iterator& input) const {
 	return parseString(input, std::set<FEATURES>({FEATURES::LINEAR, FEATURES::CYCLIC, FEATURES::EPSILON}));
 }
 
-String StringFromXMLParser::parseString(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const {
+String StringFromXMLParser::parseString(std::deque<sax::Token>::iterator& input, const std::set<FEATURES>& features) const {
 	if(alib::xmlApi<Epsilon>::first(input)) {
 		if(!features.count(FEATURES::EPSILON)) throw exception::AlibException();
 		return String(parseEpsilon(input));
@@ -27,11 +27,11 @@ String StringFromXMLParser::parseString(std::deque<sax::Token>& input, const std
 		if(!features.count(FEATURES::CYCLIC)) throw exception::AlibException();
 		return String(parseCyclicString(input));
 	} else {
-		throw sax::ParserException(sax::Token("Epsilon, LinearString, CyclicString", sax::Token::TokenType::START_ELEMENT), input.front());
+		throw sax::ParserException(sax::Token("Epsilon, LinearString, CyclicString", sax::Token::TokenType::START_ELEMENT), *input);
 	}
 }
 
-bool StringFromXMLParser::first(const std::deque<sax::Token>& input) const {
+bool StringFromXMLParser::first(const std::deque<sax::Token>::const_iterator& input) const {
 	if(alib::xmlApi<Epsilon>::first(input) || alib::xmlApi<LinearString>::first(input) || alib::xmlApi<CyclicString>::first(input)) {
 		return true;
 	} else {
@@ -39,7 +39,7 @@ bool StringFromXMLParser::first(const std::deque<sax::Token>& input) const {
 	}
 }
 
-LinearString StringFromXMLParser::parseLinearString(std::deque<sax::Token>& input) const {
+LinearString StringFromXMLParser::parseLinearString(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::STRING_LINEAR_STRING);
 
 	LinearString string;
@@ -50,7 +50,7 @@ LinearString StringFromXMLParser::parseLinearString(std::deque<sax::Token>& inpu
 	return string;
 }
 
-CyclicString StringFromXMLParser::parseCyclicString(std::deque<sax::Token>& input) const {
+CyclicString StringFromXMLParser::parseCyclicString(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::STRING_CYCLIC_STRING);
 
 	CyclicString string;
@@ -61,7 +61,7 @@ CyclicString StringFromXMLParser::parseCyclicString(std::deque<sax::Token>& inpu
 	return string;
 }
 
-Epsilon StringFromXMLParser::parseEpsilon(std::deque<sax::Token>& input) const {
+Epsilon StringFromXMLParser::parseEpsilon(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::STRING_EPSILON);
 
 	Epsilon epsilon;
@@ -71,7 +71,7 @@ Epsilon StringFromXMLParser::parseEpsilon(std::deque<sax::Token>& input) const {
 	return epsilon;
 }
 
-std::set<alphabet::Symbol> StringFromXMLParser::parseAlphabet(std::deque<sax::Token> &input) const {
+std::set<alphabet::Symbol> StringFromXMLParser::parseAlphabet(std::deque<sax::Token>::iterator& input) const {
 	std::set<alphabet::Symbol> alphabet;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "alphabet");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -81,7 +81,7 @@ std::set<alphabet::Symbol> StringFromXMLParser::parseAlphabet(std::deque<sax::To
 	return alphabet;
 }
 
-std::vector<alphabet::Symbol> StringFromXMLParser::parseContentData(std::deque<sax::Token>& input) const {
+std::vector<alphabet::Symbol> StringFromXMLParser::parseContentData(std::deque<sax::Token>::iterator& input) const {
 	std::vector<alphabet::Symbol> data;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "content");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
diff --git a/alib2data/src/string/StringFromXMLParser.h b/alib2data/src/string/StringFromXMLParser.h
index 72dbfd394e..6dd9051568 100644
--- a/alib2data/src/string/StringFromXMLParser.h
+++ b/alib2data/src/string/StringFromXMLParser.h
@@ -36,19 +36,19 @@ public:
 	StringFromXMLParser() {}
 
 private:
-	std::vector<alphabet::Symbol> parseContentData(std::deque<sax::Token>& input) const;
-	std::set<alphabet::Symbol> parseAlphabet(std::deque<sax::Token> &input) const;
+	std::vector<alphabet::Symbol> parseContentData(std::deque<sax::Token>::iterator& input) const;
+	std::set<alphabet::Symbol> parseAlphabet(std::deque<sax::Token>::iterator& input) const;
 
-	String parseString(std::deque<sax::Token>& input) const;
-	String parseString(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const;
+	String parseString(std::deque<sax::Token>::iterator& input) const;
+	String parseString(std::deque<sax::Token>::iterator& input, const std::set<FEATURES>& features) const;
 
-	LinearString parseLinearString(std::deque<sax::Token>& input) const;
-	CyclicString parseCyclicString(std::deque<sax::Token>& input) const;
-	Epsilon parseEpsilon(std::deque<sax::Token>& input) const;
+	LinearString parseLinearString(std::deque<sax::Token>::iterator& input) const;
+	CyclicString parseCyclicString(std::deque<sax::Token>::iterator& input) const;
+	Epsilon parseEpsilon(std::deque<sax::Token>::iterator& input) const;
 
 	template<typename T> friend struct alib::xmlApi;
 public:
-	bool first(const std::deque<sax::Token>& input) const;
+	bool first(const std::deque<sax::Token>::const_iterator& input) const;
 };
 
 } /* namespace string */
diff --git a/alib2data/src/tree/TreeFromRawParser.cpp b/alib2data/src/tree/TreeFromRawParser.cpp
index bc5638d2b5..94baa2943f 100644
--- a/alib2data/src/tree/TreeFromRawParser.cpp
+++ b/alib2data/src/tree/TreeFromRawParser.cpp
@@ -17,11 +17,11 @@
 
 namespace tree {
 
-Tree TreeFromRawParser::parseTree(std::deque<sax::Token>& input) const {
+Tree TreeFromRawParser::parseTree(std::deque<sax::Token>::iterator& input) const {
 	return parseTree(input, std::set<FEATURES>({FEATURES::RANKED_TREE, FEATURES::PREFIX_RANKED_TREE, FEATURES::PREFIX_RANKED_BAR_TREE, FEATURES::UNRANKED_TREE}));
 }
 
-Tree TreeFromRawParser::parseTree(std::deque<sax::Token> &input, const std::set<FEATURES>& features) const {
+Tree TreeFromRawParser::parseTree(std::deque<sax::Token>::iterator& input, const std::set<FEATURES>& features) const {
 	UnrankedNode* root = NULL;
 	if (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
 		root = this->parseContent(input);
@@ -44,7 +44,7 @@ Tree TreeFromRawParser::parseTree(std::deque<sax::Token> &input, const std::set<
 	throw exception::AlibException("Invalid input");
 }
 
-UnrankedNode* TreeFromRawParser::parseContent(std::deque<sax::Token>& input) const {
+UnrankedNode* TreeFromRawParser::parseContent(std::deque<sax::Token>::iterator& input) const {
 	UnrankedNode* node = new UnrankedNode(alphabet::symbolFrom(popTokenData(input, sax::Token::TokenType::START_ELEMENT)), std::vector<UnrankedNode*> {});
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
 		UnrankedNode* child = this->parseContent(input);
@@ -60,7 +60,7 @@ UnrankedNode* TreeFromRawParser::parseContent(std::deque<sax::Token>& input) con
 	return node;
 }
 
-UnrankedNode* TreeFromRawParser::parseContentLeaf(std::deque<sax::Token>& input) const {
+UnrankedNode* TreeFromRawParser::parseContentLeaf(std::deque<sax::Token>::iterator& input) const {
 	return new UnrankedNode(alphabet::symbolFrom(popTokenData(input, sax::Token::TokenType::CHARACTER)), std::vector<UnrankedNode*> {});
 }
 
diff --git a/alib2data/src/tree/TreeFromRawParser.h b/alib2data/src/tree/TreeFromRawParser.h
index a506012637..6733977194 100644
--- a/alib2data/src/tree/TreeFromRawParser.h
+++ b/alib2data/src/tree/TreeFromRawParser.h
@@ -21,12 +21,12 @@ class TreeFromRawParser : public sax::FromXMLParserHelper {
 public:
 	TreeFromRawParser() {}
 
-	Tree parseTree(std::deque<sax::Token> &input) const;
-	Tree parseTree(std::deque<sax::Token> &input, const std::set<FEATURES>& features) const;
+	Tree parseTree(std::deque<sax::Token>::iterator& input) const;
+	Tree parseTree(std::deque<sax::Token>::iterator& input, const std::set<FEATURES>& features) const;
 
 private:
-	UnrankedNode* parseContent(std::deque<sax::Token>& input) const;
-	UnrankedNode* parseContentLeaf(std::deque<sax::Token>& input) const;
+	UnrankedNode* parseContent(std::deque<sax::Token>::iterator& input) const;
+	UnrankedNode* parseContentLeaf(std::deque<sax::Token>::iterator& input) const;
 };
 
 } /* namespace tree */
diff --git a/alib2data/src/tree/TreeFromXMLParser.cpp b/alib2data/src/tree/TreeFromXMLParser.cpp
index 10a058806b..5a0752393e 100644
--- a/alib2data/src/tree/TreeFromXMLParser.cpp
+++ b/alib2data/src/tree/TreeFromXMLParser.cpp
@@ -13,11 +13,11 @@
 
 namespace tree {
 
-Tree TreeFromXMLParser::parseTree(std::deque<sax::Token> &input) const {
+Tree TreeFromXMLParser::parseTree(std::deque<sax::Token>::iterator& input) const {
 	return parseTree(input, std::set<FEATURES>({FEATURES::RANKED_TREE, FEATURES::RANKED_PATTERN, FEATURES::UNRANKED_TREE, FEATURES::UNRANKED_PATTERN, FEATURES::PREFIX_RANKED_TREE, FEATURES::PREFIX_RANKED_PATTERN, FEATURES::PREFIX_RANKED_BAR_PATTERN}));
 }
 
-Tree TreeFromXMLParser::parseTree(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const {
+Tree TreeFromXMLParser::parseTree(std::deque<sax::Token>::iterator& input, const std::set<FEATURES>& features) const {
 	if(alib::xmlApi<RankedTree>::first(input)) {
 		if(!features.count(FEATURES::RANKED_TREE)) throw exception::AlibException();
 		return Tree(parseRankedTree(input));
@@ -40,10 +40,10 @@ Tree TreeFromXMLParser::parseTree(std::deque<sax::Token>& input, const std::set<
 		if(!features.count(FEATURES::PREFIX_RANKED_BAR_PATTERN)) throw exception::AlibException();
 		return Tree(parsePrefixRankedBarPattern(input));
 	} else
-		throw sax::ParserException(sax::Token("Tree / RankedTree / RankedPattern / PrefixRankedTree / PrefixRankedPattern / PrefixRankedBarPattern / UnrankedTree / UnrankedPattern", sax::Token::TokenType::START_ELEMENT), input.front());
+		throw sax::ParserException(sax::Token("Tree / RankedTree / RankedPattern / PrefixRankedTree / PrefixRankedPattern / PrefixRankedBarPattern / UnrankedTree / UnrankedPattern", sax::Token::TokenType::START_ELEMENT), *input);
 }
 
-RankedPattern TreeFromXMLParser::parseRankedPattern(std::deque<sax::Token>& input) const {
+RankedPattern TreeFromXMLParser::parseRankedPattern(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::TREE_RANKED_PATTERN);
 
 	alphabet::RankedSymbol subtreeWildcard = parseSubtreeWildcard<alphabet::RankedSymbol>(input);
@@ -55,7 +55,7 @@ RankedPattern TreeFromXMLParser::parseRankedPattern(std::deque<sax::Token>& inpu
 	return tree;
 }
 
-RankedTree TreeFromXMLParser::parseRankedTree(std::deque<sax::Token>& input) const {
+RankedTree TreeFromXMLParser::parseRankedTree(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::TREE_RANKED_TREE);
 
 	std::set<alphabet::RankedSymbol> rankedAlphabet = parseRankedAlphabet(input);
@@ -66,7 +66,7 @@ RankedTree TreeFromXMLParser::parseRankedTree(std::deque<sax::Token>& input) con
 	return tree;
 }
 
-PrefixRankedTree TreeFromXMLParser::parsePrefixRankedTree(std::deque<sax::Token>& input) const {
+PrefixRankedTree TreeFromXMLParser::parsePrefixRankedTree(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::TREE_PREFIX_RANKED_TREE);
 
 	std::set<alphabet::RankedSymbol> rankedAlphabet = parseRankedAlphabet(input);
@@ -77,7 +77,7 @@ PrefixRankedTree TreeFromXMLParser::parsePrefixRankedTree(std::deque<sax::Token>
 	return tree;
 }
 
-PrefixRankedBarTree TreeFromXMLParser::parsePrefixRankedBarTree(std::deque<sax::Token>& input) const {
+PrefixRankedBarTree TreeFromXMLParser::parsePrefixRankedBarTree(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::TREE_PREFIX_RANKED_BAR_TREE);
 
 	alphabet::Symbol bar = parseBar(input);
@@ -89,7 +89,7 @@ PrefixRankedBarTree TreeFromXMLParser::parsePrefixRankedBarTree(std::deque<sax::
 	return tree;
 }
 
-PrefixRankedPattern TreeFromXMLParser::parsePrefixRankedPattern(std::deque<sax::Token>& input) const {
+PrefixRankedPattern TreeFromXMLParser::parsePrefixRankedPattern(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::TREE_PREFIX_RANKED_PATTERN);
 
 	alphabet::RankedSymbol subtreeWildcard = parseSubtreeWildcard<alphabet::RankedSymbol>(input);
@@ -101,7 +101,7 @@ PrefixRankedPattern TreeFromXMLParser::parsePrefixRankedPattern(std::deque<sax::
 	return tree;
 }
 
-PrefixRankedBarPattern TreeFromXMLParser::parsePrefixRankedBarPattern(std::deque<sax::Token>& input) const {
+PrefixRankedBarPattern TreeFromXMLParser::parsePrefixRankedBarPattern(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::TREE_PREFIX_RANKED_BAR_PATTERN);
 
 	alphabet::Symbol bar = parseBar(input);
@@ -115,7 +115,7 @@ PrefixRankedBarPattern TreeFromXMLParser::parsePrefixRankedBarPattern(std::deque
 	return tree;
 }
 
-UnrankedPattern TreeFromXMLParser::parseUnrankedPattern(std::deque<sax::Token>& input) const {
+UnrankedPattern TreeFromXMLParser::parseUnrankedPattern(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::TREE_UNRANKED_PATTERN);
 
 	alphabet::Symbol subtreeWildcard = parseSubtreeWildcard<alphabet::Symbol>(input);
@@ -127,7 +127,7 @@ UnrankedPattern TreeFromXMLParser::parseUnrankedPattern(std::deque<sax::Token>&
 	return tree;
 }
 
-UnrankedTree TreeFromXMLParser::parseUnrankedTree(std::deque<sax::Token>& input) const {
+UnrankedTree TreeFromXMLParser::parseUnrankedTree(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::TREE_UNRANKED_TREE);
 
 	std::set<alphabet::Symbol> alphabet = parseAlphabet(input);
@@ -138,14 +138,14 @@ UnrankedTree TreeFromXMLParser::parseUnrankedTree(std::deque<sax::Token>& input)
 	return tree;
 }
 
-alphabet::Symbol TreeFromXMLParser::parseBar(std::deque<sax::Token>& input) const {
+alphabet::Symbol TreeFromXMLParser::parseBar(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "bar");
 	alphabet::Symbol bar(alib::xmlApi<alphabet::Symbol>::parse(input));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "bar");
 	return bar;
 }
 
-alphabet::Symbol TreeFromXMLParser::parseVariablesBar(std::deque<sax::Token>& input) const {
+alphabet::Symbol TreeFromXMLParser::parseVariablesBar(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "variablesBar");
 	alphabet::Symbol variablesBar(alib::xmlApi<alphabet::Symbol>::parse(input));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "variablesBar");
@@ -153,14 +153,14 @@ alphabet::Symbol TreeFromXMLParser::parseVariablesBar(std::deque<sax::Token>& in
 }
 
 template<class T>
-T TreeFromXMLParser::parseSubtreeWildcard(std::deque<sax::Token>& input) const {
+T TreeFromXMLParser::parseSubtreeWildcard(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "subtreeWildcard");
 	T subtreeWildcard(alib::xmlApi<T>::parse(input));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "subtreeWildcard");
 	return subtreeWildcard;
 }
 
-std::set<alphabet::RankedSymbol> TreeFromXMLParser::parseRankedAlphabet(std::deque<sax::Token> &input) const {
+std::set<alphabet::RankedSymbol> TreeFromXMLParser::parseRankedAlphabet(std::deque<sax::Token>::iterator& input) const {
 	std::set<alphabet::RankedSymbol> rankedSymbols;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "rankedAlphabet");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -170,7 +170,7 @@ std::set<alphabet::RankedSymbol> TreeFromXMLParser::parseRankedAlphabet(std::deq
 	return rankedSymbols;
 }
 
-std::set<alphabet::Symbol> TreeFromXMLParser::parseAlphabet(std::deque<sax::Token> &input) const {
+std::set<alphabet::Symbol> TreeFromXMLParser::parseAlphabet(std::deque<sax::Token>::iterator& input) const {
 	std::set<alphabet::Symbol> symbols;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "alphabet");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -180,7 +180,7 @@ std::set<alphabet::Symbol> TreeFromXMLParser::parseAlphabet(std::deque<sax::Toke
 	return symbols;
 }
 
-std::vector<alphabet::RankedSymbol> TreeFromXMLParser::parseContentData(std::deque<sax::Token>& input) const {
+std::vector<alphabet::RankedSymbol> TreeFromXMLParser::parseContentData(std::deque<sax::Token>::iterator& input) const {
 	std::vector<alphabet::RankedSymbol> data;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "content");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -190,7 +190,7 @@ std::vector<alphabet::RankedSymbol> TreeFromXMLParser::parseContentData(std::deq
 	return data;
 }
 
-RankedNode * TreeFromXMLParser::parseRankedNode(std::deque<sax::Token> &input) const {
+RankedNode * TreeFromXMLParser::parseRankedNode(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "rankedNode");
 	alphabet::RankedSymbol symbol = alib::xmlApi<alphabet::RankedSymbol>::parse(input);
 	int rank = symbol.getRank().getData();
@@ -204,7 +204,7 @@ RankedNode * TreeFromXMLParser::parseRankedNode(std::deque<sax::Token> &input) c
 	return new RankedNode(symbol, children);
 }
 
-UnrankedNode * TreeFromXMLParser::parseUnrankedNode(std::deque<sax::Token> &input) const {
+UnrankedNode * TreeFromXMLParser::parseUnrankedNode(std::deque<sax::Token>::iterator& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "unrankedNode");
 	alphabet::Symbol symbol = alib::xmlApi<alphabet::Symbol>::parse(input);
 	std::vector<UnrankedNode *> children;
@@ -216,7 +216,7 @@ UnrankedNode * TreeFromXMLParser::parseUnrankedNode(std::deque<sax::Token> &inpu
 	return new UnrankedNode(symbol, children);
 }
 
-bool TreeFromXMLParser::first(const std::deque<sax::Token>& input) const {
+bool TreeFromXMLParser::first(const std::deque<sax::Token>::const_iterator& input) const {
 	if (alib::xmlApi<RankedTree>::first(input) || alib::xmlApi<RankedPattern>::first(input) || alib::xmlApi<PrefixRankedTree>::first(input)  || alib::xmlApi<PrefixRankedPattern>::first(input) || alib::xmlApi<UnrankedTree>::first(input) || alib::xmlApi<UnrankedPattern>::first(input)) {
 		return true;
 	} else {
diff --git a/alib2data/src/tree/TreeFromXMLParser.h b/alib2data/src/tree/TreeFromXMLParser.h
index 66eebf3780..208f6a764c 100644
--- a/alib2data/src/tree/TreeFromXMLParser.h
+++ b/alib2data/src/tree/TreeFromXMLParser.h
@@ -36,33 +36,33 @@ public:
 	TreeFromXMLParser() {}
 
 private:
-	RankedNode * parseRankedNode(std::deque<sax::Token> &input) const;
-	std::vector<alphabet::RankedSymbol> parseContentData(std::deque<sax::Token> &input) const;
-	UnrankedNode * parseUnrankedNode(std::deque<sax::Token> &input) const;
-	std::set<alphabet::RankedSymbol> parseRankedAlphabet(std::deque<sax::Token> &input) const;
-	std::set<alphabet::Symbol> parseAlphabet(std::deque<sax::Token> &input) const;
+	RankedNode * parseRankedNode(std::deque<sax::Token>::iterator& input) const;
+	std::vector<alphabet::RankedSymbol> parseContentData(std::deque<sax::Token>::iterator& input) const;
+	UnrankedNode * parseUnrankedNode(std::deque<sax::Token>::iterator& input) const;
+	std::set<alphabet::RankedSymbol> parseRankedAlphabet(std::deque<sax::Token>::iterator& input) const;
+	std::set<alphabet::Symbol> parseAlphabet(std::deque<sax::Token>::iterator& input) const;
 
-	alphabet::Symbol parseBar(std::deque<sax::Token> &input) const;
-	alphabet::Symbol parseVariablesBar(std::deque<sax::Token> &input) const;
+	alphabet::Symbol parseBar(std::deque<sax::Token>::iterator& input) const;
+	alphabet::Symbol parseVariablesBar(std::deque<sax::Token>::iterator& input) const;
 
 	template<class T>
-	T parseSubtreeWildcard(std::deque<sax::Token> &input) const;
+	T parseSubtreeWildcard(std::deque<sax::Token>::iterator& input) const;
 
-	Tree parseTree(std::deque<sax::Token>& input) const;
-	Tree parseTree(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const;
+	Tree parseTree(std::deque<sax::Token>::iterator& input) const;
+	Tree parseTree(std::deque<sax::Token>::iterator& input, const std::set<FEATURES>& features) const;
 
-	RankedTree parseRankedTree(std::deque<sax::Token>& input) const;
-	RankedPattern parseRankedPattern(std::deque<sax::Token>& input) const;
-	PrefixRankedTree parsePrefixRankedTree(std::deque<sax::Token>& input) const;
-	PrefixRankedBarTree parsePrefixRankedBarTree(std::deque<sax::Token>& input) const;
-	PrefixRankedPattern parsePrefixRankedPattern(std::deque<sax::Token>& input) const;
-	PrefixRankedBarPattern parsePrefixRankedBarPattern(std::deque<sax::Token>& input) const;
-	UnrankedTree parseUnrankedTree(std::deque<sax::Token>& input) const;
-	UnrankedPattern parseUnrankedPattern(std::deque<sax::Token>& input) const;
+	RankedTree parseRankedTree(std::deque<sax::Token>::iterator& input) const;
+	RankedPattern parseRankedPattern(std::deque<sax::Token>::iterator& input) const;
+	PrefixRankedTree parsePrefixRankedTree(std::deque<sax::Token>::iterator& input) const;
+	PrefixRankedBarTree parsePrefixRankedBarTree(std::deque<sax::Token>::iterator& input) const;
+	PrefixRankedPattern parsePrefixRankedPattern(std::deque<sax::Token>::iterator& input) const;
+	PrefixRankedBarPattern parsePrefixRankedBarPattern(std::deque<sax::Token>::iterator& input) const;
+	UnrankedTree parseUnrankedTree(std::deque<sax::Token>::iterator& input) const;
+	UnrankedPattern parseUnrankedPattern(std::deque<sax::Token>::iterator& input) const;
 
 	template<typename T> friend struct alib::xmlApi;
 public:
-	bool first(const std::deque<sax::Token>& input) const;
+	bool first(const std::deque<sax::Token>::const_iterator& input) const;
 };
 
 } /* namespace tree */
diff --git a/araw2/src/araw.cpp b/araw2/src/araw.cpp
index 525417f121..356a1138bd 100644
--- a/araw2/src/araw.cpp
+++ b/araw2/src/araw.cpp
@@ -52,7 +52,8 @@ int main(int argc, char** argv) {
 				sax::SaxParseInterface::parseStdin(tokens);
 			}
 
-			tree::Tree tree = alib::FromRawParsers::treeParser.parseTree(tokens);
+			std::deque<sax::Token>::iterator iter = tokens.begin();
+			tree::Tree tree = alib::FromRawParsers::treeParser.parseTree(iter);
 			alib::XmlDataFactory::toStdout(tree);
 		} else if(tree_to_raw.getValue()) {
 			std::deque<sax::Token> tokens;
-- 
GitLab