diff --git a/aconversions2/src/ConversionHandler.cpp b/aconversions2/src/ConversionHandler.cpp
index 99955d0f316c62077b76c6e3c9623520b97b8a31..3b051c1464ce0b2390ace9a87e88477d9170c74b 100644
--- a/aconversions2/src/ConversionHandler.cpp
+++ b/aconversions2/src/ConversionHandler.cpp
@@ -298,17 +298,17 @@ ConversionHandler::TFormalism ConversionHandler::parseFormalismFromTokens( void
{
std::string xmlMark = m_tokens.front( ).getData( );
- if( xmlMark == "automaton" || xmlMark == "NFA" || xmlMark == "DFA" )
+ if( xmlMark == alib::Names::AUTOMATON_NFA || xmlMark == alib::Names::AUTOMATON_DFA )
return FINITE_AUTOMATON;
- if( xmlMark == "regexp" || xmlMark == "unboundedRegexp" || xmlMark == "formalRegExp")
+ if( xmlMark == alib::Names::REGEXP_UNBOUNDED_REGEXP || xmlMark == alib::Names::REGEXP_FORMAL_REGEXP)
return REGULAR_EXPRESSION;
- if( xmlMark == "RightRG" )
+ if( xmlMark == alib::Names::GRAMMAR_RIGHT_RG )
return RIGHT_REGULAR_GRAMMAR;
- if( xmlMark == "LeftRG" )
- return LEFT_REGULAR_GRAMMAR;
+ if( xmlMark == alib::Names::GRAMMAR_LEFT_RG )
+ return LEFT_REGULAR_GRAMMAR;
throw exception::AlibException( "ConversionHandler: Invalid input formalism." );
}
diff --git a/alib2data/src/Api.cpp b/alib2data/src/Api.cpp
index 922ebe62aa5601e1d637795b5715320e61a258da..f0d1b9f06210a9d4676071d6a02bbf684714f8de 100644
--- a/alib2data/src/Api.cpp
+++ b/alib2data/src/Api.cpp
@@ -33,10 +33,75 @@ const primitive::PrimitiveToXMLComposer ToXMLComposers::primitiveComposer;
const ToXMLComposers ToXMLComposers::toXMLComposers;
+const std::string Names::ALIB_VOID = "Void";
+const std::string Names::CONTAINER_OBJECTS_SET = "ObjectsSet";
+const std::string Names::CONTAINER_OBJECTS_VECTOR = "ObjectsVector";
+const std::string Names::CONTAINER_OBJECTS_PAIR = "ObjectsPair";
+const std::string Names::CONTAINER_OBJECTS_MAP = "ObjectsMap";
+const std::string Names::EXCEPTION_ALIB_EXCEPTION = "AlibException";
+const std::string Names::ALPHABET_LABELED_SYMBOL = "LabeledSymbol";
+const std::string Names::ALPHABET_BLANK_SYMBOL = "BlankSymbol";
+const std::string Names::ALPHABET_BOTTOM_OF_THE_STACK_SYMBOL = "BottomOfTheStackSymbol";
+const std::string Names::ALPHABET_END_SYMBOL = "EndSymbol";
+const std::string Names::ALPHABET_RANKED_SYMBOL = "RankedSymbol";
+const std::string Names::ALPHABET_BAR_SYMBOL = "BarSymbol";
+const std::string Names::ALPHABET_RANKED_BAR_SYMBOL = "RankedBarSymbol";
+const std::string Names::ALPHABET_SUBTREE_WILDCARD_SYMBOL = "SubtreeWildcardSymbol";
+const std::string Names::AUTOMATON_EPSILON_NFA = "EpsilonNFA";
+const std::string Names::AUTOMATON_MULTI_INITIAL_STATE_NFA = "MultiInitialStateNFA";
+const std::string Names::AUTOMATON_NFA = "NFA";
+const std::string Names::AUTOMATON_DFA = "DFA";
+const std::string Names::AUTOMATON_EXTENDED_NFA = "ExtendedNFA";
+const std::string Names::AUTOMATON_COMPACT_NFA = "CompactNFA";
+const std::string Names::AUTOMATON_DPDA = "DPDA";
+const std::string Names::AUTOMATON_SINGLE_POP_DPDA = "SinglePopDPDA";
+const std::string Names::AUTOMATON_INPUT_DRIVEN_NPDA = "InputDrivenNPDA";
+const std::string Names::AUTOMATON_VISIBLY_PUSHDOWN_DPDA = "VisiblyPushdownDPDA";
+const std::string Names::AUTOMATON_VISIBLY_PUSHDOWN_NPDA = "VisiblyPushdownNPDA";
+const std::string Names::AUTOMATON_REAL_TIME_HEIGHT_DETERMINISTIC_DPDA = "RealTimeHeightDeterministicDPDA";
+const std::string Names::AUTOMATON_REAL_TIME_HEIGHT_DETERMINISTIC_NPDA = "RealTimeHeightDeterministicNPDA";
+const std::string Names::AUTOMATON_NPDA = "NPDA";
+const std::string Names::AUTOMATON_SINGLE_POP_NPDA = "SinglePopNPDA";
+const std::string Names::AUTOMATON_ONE_TAPE_DTM = "OneTapeDTM";
+const std::string Names::AUTOMATON_STATE = "State";
+const std::string Names::GRAMMAR_LEFT_LG = "LeftLG";
+const std::string Names::GRAMMAR_LEFT_RG = "LeftRG";
+const std::string Names::GRAMMAR_RIGHT_LG = "RightLG";
+const std::string Names::GRAMMAR_RIGHT_RG = "RightRG";
+const std::string Names::GRAMMAR_LG = "LG";
+const std::string Names::GRAMMAR_CFG = "CFG";
+const std::string Names::GRAMMAR_EPSILON_FREE_CFG = "EpsilonFreeCFG";
+const std::string Names::GRAMMAR_CNF = "CNF";
+const std::string Names::GRAMMAR_GNF = "GNF";
+const std::string Names::GRAMMAR_CSG = "CSG";
+const std::string Names::GRAMMAR_NON_CONTRACTING_GRAMMAR = "NonContractingGrammar";
+const std::string Names::GRAMMAR_CONTEXT_PRESERVING_UNRESTRICTED_GRAMMAR = "ContextPpreservingUnrestrictedGrammar";
+const std::string Names::GRAMMAR_UNRESTRICTED_GRAMMAR = "UnrestrictedGrammar";
+const std::string Names::LABEL_PRIMITIVE_LABEL = "PrimitiveLabel";
+const std::string Names::LABEL_HEXAVIGESIMAL_LABEL = "HexavigesimalLabel";
+const std::string Names::LABEL_OBJECT_LABEL = "ObjectLabel";
+const std::string Names::LABEL_LABEL_SET_LABEL = "LabelSetLabel";
+const std::string Names::LABEL_LABEL_PAIR_LABEL = "LabelPairLabel";
+const std::string Names::REGEXP_UNBOUNDED_REGEXP = "UnboundedRegExp";
+const std::string Names::REGEXP_FORMAL_REGEXP = "FormalRegExp";
+const std::string Names::STRING_LINEAR_STRING = "LinearString";
+const std::string Names::STRING_CYCLIC_STRING = "CyclicString";
+const std::string Names::STRING_EPSILON = "Epsilon";
+const std::string Names::PRIMITIVE_PRIMITIVE = "Primitive";
+const std::string Names::PRIMITIVE_STRING = "String";
+const std::string Names::PRIMITIVE_INTEGER = "Integer";
+const std::string Names::PRIMITIVE_CHARACTER = "Character";
+const std::string Names::PRIMITIVE_UNSIGNED = "Unsigned";
+const std::string Names::PRIMITIVE_BOOL = "Bool";
+
Void api<Void>::parse(std::list<sax::Token>& input) {
return FromXMLParsers::objectParser.parseVoid(input);
}
+bool api<Void>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALIB_VOID);
+}
+
std::list<sax::Token> api<Void>::compose(const Void& data) {
return ToXMLComposers::objectComposer.compose(data);
}
@@ -45,6 +110,10 @@ container::Container api<container::Container>::parse(std::list<sax::Token>& inp
return FromXMLParsers::containerParser.parseContainer(input);
}
+bool api<container::Container>::first(const std::list<sax::Token>& input) {
+ return FromXMLParsers::containerParser.first(input);
+}
+
std::list<sax::Token> api<container::Container>::compose(const container::Container& data) {
return ToXMLComposers::containerComposer.compose(data);
}
@@ -53,6 +122,10 @@ container::ObjectsSet api<container::ObjectsSet>::parse(std::list<sax::Token>& i
return FromXMLParsers::containerParser.parseObjectsSet(input);
}
+bool api<container::ObjectsSet>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::CONTAINER_OBJECTS_SET);
+}
+
std::list<sax::Token> api<container::ObjectsSet>::compose(const container::ObjectsSet& data) {
return ToXMLComposers::containerComposer.compose(data);
}
@@ -61,6 +134,10 @@ container::ObjectsVector api<container::ObjectsVector>::parse(std::list<sax::Tok
return FromXMLParsers::containerParser.parseObjectsVector(input);
}
+bool api<container::ObjectsVector>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::CONTAINER_OBJECTS_VECTOR);
+}
+
std::list<sax::Token> api<container::ObjectsVector>::compose(const container::ObjectsVector& data) {
return ToXMLComposers::containerComposer.compose(data);
}
@@ -69,6 +146,10 @@ container::ObjectsPair api<container::ObjectsPair>::parse(std::list<sax::Token>&
return FromXMLParsers::containerParser.parseObjectsPair(input);
}
+bool api<container::ObjectsPair>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::CONTAINER_OBJECTS_PAIR);
+}
+
std::list<sax::Token> api<container::ObjectsPair>::compose(const container::ObjectsPair& data) {
return ToXMLComposers::containerComposer.compose(data);
}
@@ -77,6 +158,10 @@ container::ObjectsMap api<container::ObjectsMap>::parse(std::list<sax::Token>& i
return FromXMLParsers::containerParser.parseObjectsMap(input);
}
+bool api<container::ObjectsMap>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::CONTAINER_OBJECTS_MAP);
+}
+
std::list<sax::Token> api<container::ObjectsMap>::compose(const container::ObjectsMap& data) {
return ToXMLComposers::containerComposer.compose(data);
}
@@ -85,6 +170,10 @@ alib::Object api<alib::Object>::parse(std::list<sax::Token>& input) {
return FromXMLParsers::objectParser.parseObject(input);
}
+bool api<alib::Object>::first(const std::list<sax::Token>& input) {
+ return FromXMLParsers::objectParser.first(input);
+}
+
std::list<sax::Token> api<alib::Object>::compose(const alib::Object& data) {
return ToXMLComposers::objectComposer.compose(data);
}
@@ -93,6 +182,10 @@ exception::AlibException api<exception::AlibException>::parse(std::list<sax::Tok
return FromXMLParsers::exceptionParser.parseException(input);
}
+bool api<exception::AlibException>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::EXCEPTION_ALIB_EXCEPTION);
+}
+
std::list<sax::Token> api<exception::AlibException>::compose(const exception::AlibException& data) {
return ToXMLComposers::exceptionComposer.compose(data);
}
@@ -101,6 +194,10 @@ alphabet::Symbol api<alphabet::Symbol>::parse(std::list<sax::Token>& input) {
return FromXMLParsers::symbolParser.parseSymbol(input);
}
+bool api<alphabet::Symbol>::first(const std::list<sax::Token>& input) {
+ return FromXMLParsers::symbolParser.first(input);
+}
+
std::list<sax::Token> api<alphabet::Symbol>::compose(const alphabet::Symbol& data) {
return ToXMLComposers::symbolComposer.compose(data);
}
@@ -109,6 +206,10 @@ alphabet::LabeledSymbol api<alphabet::LabeledSymbol>::parse(std::list<sax::Token
return FromXMLParsers::symbolParser.parseLabeledSymbol(input);
}
+bool api<alphabet::LabeledSymbol>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALPHABET_LABELED_SYMBOL);
+}
+
std::list<sax::Token> api<alphabet::LabeledSymbol>::compose(const alphabet::LabeledSymbol& data) {
return ToXMLComposers::symbolComposer.compose(data);
}
@@ -117,6 +218,10 @@ alphabet::BlankSymbol api<alphabet::BlankSymbol>::parse(std::list<sax::Token>& i
return FromXMLParsers::symbolParser.parseBlankSymbol(input);
}
+bool api<alphabet::BlankSymbol>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALPHABET_BLANK_SYMBOL);
+}
+
std::list<sax::Token> api<alphabet::BlankSymbol>::compose(const alphabet::BlankSymbol& data) {
return ToXMLComposers::symbolComposer.compose(data);
}
@@ -125,6 +230,10 @@ alphabet::BottomOfTheStackSymbol api<alphabet::BottomOfTheStackSymbol>::parse(st
return FromXMLParsers::symbolParser.parseBottomOfTheStackSymbol(input);
}
+bool api<alphabet::BottomOfTheStackSymbol>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALPHABET_BOTTOM_OF_THE_STACK_SYMBOL);
+}
+
std::list<sax::Token> api<alphabet::BottomOfTheStackSymbol>::compose(const alphabet::BottomOfTheStackSymbol& data) {
return ToXMLComposers::symbolComposer.compose(data);
}
@@ -133,6 +242,10 @@ alphabet::EndSymbol api<alphabet::EndSymbol>::parse(std::list<sax::Token>& input
return FromXMLParsers::symbolParser.parseEndSymbol(input);
}
+bool api<alphabet::EndSymbol>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALPHABET_END_SYMBOL);
+}
+
std::list<sax::Token> api<alphabet::EndSymbol>::compose(const alphabet::EndSymbol& data) {
return ToXMLComposers::symbolComposer.compose(data);
}
@@ -141,6 +254,10 @@ alphabet::RankedSymbol api<alphabet::RankedSymbol>::parse(std::list<sax::Token>&
return FromXMLParsers::symbolParser.parseRankedSymbol(input);
}
+bool api<alphabet::RankedSymbol>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALPHABET_RANKED_SYMBOL);
+}
+
std::list<sax::Token> api<alphabet::RankedSymbol>::compose(const alphabet::RankedSymbol& data) {
return ToXMLComposers::symbolComposer.compose(data);
}
@@ -149,6 +266,10 @@ alphabet::BarSymbol api<alphabet::BarSymbol>::parse(std::list<sax::Token>& input
return FromXMLParsers::symbolParser.parseBarSymbol(input);
}
+bool api<alphabet::BarSymbol>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALPHABET_BAR_SYMBOL);
+}
+
std::list<sax::Token> api<alphabet::BarSymbol>::compose(const alphabet::BarSymbol& data) {
return ToXMLComposers::symbolComposer.compose(data);
}
@@ -157,6 +278,10 @@ alphabet::RankedBarSymbol api<alphabet::RankedBarSymbol>::parse(std::list<sax::T
return FromXMLParsers::symbolParser.parseRankedBarSymbol(input);
}
+bool api<alphabet::RankedBarSymbol>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALPHABET_RANKED_BAR_SYMBOL);
+}
+
std::list<sax::Token> api<alphabet::RankedBarSymbol>::compose(const alphabet::RankedBarSymbol& data) {
return ToXMLComposers::symbolComposer.compose(data);
}
@@ -165,6 +290,10 @@ alphabet::SubtreeWildcardSymbol api<alphabet::SubtreeWildcardSymbol>::parse(std:
return FromXMLParsers::symbolParser.parseSubtreeWildcardSymbol(input);
}
+bool api<alphabet::SubtreeWildcardSymbol>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALPHABET_SUBTREE_WILDCARD_SYMBOL);
+}
+
std::list<sax::Token> api<alphabet::SubtreeWildcardSymbol>::compose(const alphabet::SubtreeWildcardSymbol& data) {
return ToXMLComposers::symbolComposer.compose(data);
}
@@ -174,6 +303,10 @@ automaton::Automaton api<automaton::Automaton>::parse(std::list<sax::Token>& inp
return FromXMLParsers::automatonParser.parseAutomaton(input);
}
+bool api<automaton::Automaton>::first(const std::list<sax::Token>& input) {
+ return FromXMLParsers::automatonParser.first(input);
+}
+
std::list<sax::Token> api<automaton::Automaton>::compose(const automaton::Automaton& data) {
return ToXMLComposers::automatonComposer.compose(data);
}
@@ -182,6 +315,10 @@ automaton::EpsilonNFA api<automaton::EpsilonNFA>::parse(std::list<sax::Token>& i
return FromXMLParsers::automatonParser.parseEpsilonNFA(input);
}
+bool api<automaton::EpsilonNFA>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_EPSILON_NFA);
+}
+
std::list<sax::Token> api<automaton::EpsilonNFA>::compose(const automaton::EpsilonNFA& data) {
return ToXMLComposers::automatonComposer.compose(data);
}
@@ -190,6 +327,10 @@ automaton::MultiInitialStateNFA api<automaton::MultiInitialStateNFA>::parse(std:
return FromXMLParsers::automatonParser.parseMultiInitialStateNFA(input);
}
+bool api<automaton::MultiInitialStateNFA>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_MULTI_INITIAL_STATE_NFA);
+}
+
std::list<sax::Token> api<automaton::MultiInitialStateNFA>::compose(const automaton::MultiInitialStateNFA& data) {
return ToXMLComposers::automatonComposer.compose(data);
}
@@ -198,6 +339,10 @@ automaton::NFA api<automaton::NFA>::parse(std::list<sax::Token>& input) {
return FromXMLParsers::automatonParser.parseNFA(input);
}
+bool api<automaton::NFA>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_NFA);
+}
+
std::list<sax::Token> api<automaton::NFA>::compose(const automaton::NFA& data) {
return ToXMLComposers::automatonComposer.compose(data);
}
@@ -206,6 +351,10 @@ automaton::DFA api<automaton::DFA>::parse(std::list<sax::Token>& input) {
return FromXMLParsers::automatonParser.parseDFA(input);
}
+bool api<automaton::DFA>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_DFA);
+}
+
std::list<sax::Token> api<automaton::DFA>::compose(const automaton::DFA& data) {
return ToXMLComposers::automatonComposer.compose(data);
}
@@ -214,6 +363,10 @@ automaton::ExtendedNFA api<automaton::ExtendedNFA>::parse(std::list<sax::Token>&
return FromXMLParsers::automatonParser.parseExtendedNFA(input);
}
+bool api<automaton::ExtendedNFA>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_EXTENDED_NFA);
+}
+
std::list<sax::Token> api<automaton::ExtendedNFA>::compose(const automaton::ExtendedNFA& data) {
return ToXMLComposers::automatonComposer.compose(data);
}
@@ -222,6 +375,10 @@ automaton::CompactNFA api<automaton::CompactNFA>::parse(std::list<sax::Token>& i
return FromXMLParsers::automatonParser.parseCompactNFA(input);
}
+bool api<automaton::CompactNFA>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_COMPACT_NFA);
+}
+
std::list<sax::Token> api<automaton::CompactNFA>::compose(const automaton::CompactNFA& data) {
return ToXMLComposers::automatonComposer.compose(data);
}
@@ -230,6 +387,10 @@ automaton::DPDA api<automaton::DPDA>::parse(std::list<sax::Token>& input) {
return FromXMLParsers::automatonParser.parseDPDA(input);
}
+bool api<automaton::DPDA>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_DPDA);
+}
+
std::list<sax::Token> api<automaton::DPDA>::compose(const automaton::DPDA& data) {
return ToXMLComposers::automatonComposer.compose(data);
}
@@ -238,6 +399,10 @@ automaton::SinglePopDPDA api<automaton::SinglePopDPDA>::parse(std::list<sax::Tok
return FromXMLParsers::automatonParser.parseSinglePopDPDA(input);
}
+bool api<automaton::SinglePopDPDA>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_SINGLE_POP_DPDA);
+}
+
std::list<sax::Token> api<automaton::SinglePopDPDA>::compose(const automaton::SinglePopDPDA& data) {
return ToXMLComposers::automatonComposer.compose(data);
}
@@ -246,6 +411,10 @@ automaton::InputDrivenNPDA api<automaton::InputDrivenNPDA>::parse(std::list<sax:
return FromXMLParsers::automatonParser.parseInputDrivenNPDA(input);
}
+bool api<automaton::InputDrivenNPDA>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_INPUT_DRIVEN_NPDA);
+}
+
std::list<sax::Token> api<automaton::InputDrivenNPDA>::compose(const automaton::InputDrivenNPDA& data) {
return ToXMLComposers::automatonComposer.compose(data);
}
@@ -254,6 +423,10 @@ automaton::VisiblyPushdownDPDA api<automaton::VisiblyPushdownDPDA>::parse(std::l
return FromXMLParsers::automatonParser.parseVisiblyPushdownDPDA(input);
}
+bool api<automaton::VisiblyPushdownDPDA>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_VISIBLY_PUSHDOWN_DPDA);
+}
+
std::list<sax::Token> api<automaton::VisiblyPushdownDPDA>::compose(const automaton::VisiblyPushdownDPDA& data) {
return ToXMLComposers::automatonComposer.compose(data);
}
@@ -262,6 +435,10 @@ automaton::VisiblyPushdownNPDA api<automaton::VisiblyPushdownNPDA>::parse(std::l
return FromXMLParsers::automatonParser.parseVisiblyPushdownNPDA(input);
}
+bool api<automaton::VisiblyPushdownNPDA>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_VISIBLY_PUSHDOWN_NPDA);
+}
+
std::list<sax::Token> api<automaton::VisiblyPushdownNPDA>::compose(const automaton::VisiblyPushdownNPDA& data) {
return ToXMLComposers::automatonComposer.compose(data);
}
@@ -270,6 +447,10 @@ automaton::RealTimeHeightDeterministicDPDA api<automaton::RealTimeHeightDetermin
return FromXMLParsers::automatonParser.parseRealTimeHeightDeterministicDPDA(input);
}
+bool api<automaton::RealTimeHeightDeterministicDPDA>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_REAL_TIME_HEIGHT_DETERMINISTIC_DPDA);
+}
+
std::list<sax::Token> api<automaton::RealTimeHeightDeterministicDPDA>::compose(const automaton::RealTimeHeightDeterministicDPDA& data) {
return ToXMLComposers::automatonComposer.compose(data);
}
@@ -278,6 +459,10 @@ automaton::RealTimeHeightDeterministicNPDA api<automaton::RealTimeHeightDetermin
return FromXMLParsers::automatonParser.parseRealTimeHeightDeterministicNPDA(input);
}
+bool api<automaton::RealTimeHeightDeterministicNPDA>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_REAL_TIME_HEIGHT_DETERMINISTIC_NPDA);
+}
+
std::list<sax::Token> api<automaton::RealTimeHeightDeterministicNPDA>::compose(const automaton::RealTimeHeightDeterministicNPDA& data) {
return ToXMLComposers::automatonComposer.compose(data);
}
@@ -286,6 +471,10 @@ automaton::NPDA api<automaton::NPDA>::parse(std::list<sax::Token>& input) {
return FromXMLParsers::automatonParser.parseNPDA(input);
}
+bool api<automaton::NPDA>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_NPDA);
+}
+
std::list<sax::Token> api<automaton::NPDA>::compose(const automaton::NPDA& data) {
return ToXMLComposers::automatonComposer.compose(data);
}
@@ -294,6 +483,10 @@ automaton::SinglePopNPDA api<automaton::SinglePopNPDA>::parse(std::list<sax::Tok
return FromXMLParsers::automatonParser.parseSinglePopNPDA(input);
}
+bool api<automaton::SinglePopNPDA>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_SINGLE_POP_NPDA);
+}
+
std::list<sax::Token> api<automaton::SinglePopNPDA>::compose(const automaton::SinglePopNPDA& data) {
return ToXMLComposers::automatonComposer.compose(data);
}
@@ -302,6 +495,10 @@ automaton::OneTapeDTM api<automaton::OneTapeDTM>::parse(std::list<sax::Token>& i
return FromXMLParsers::automatonParser.parseOneTapeDTM(input);
}
+bool api<automaton::OneTapeDTM>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_ONE_TAPE_DTM);
+}
+
std::list<sax::Token> api<automaton::OneTapeDTM>::compose(const automaton::OneTapeDTM& data) {
return ToXMLComposers::automatonComposer.compose(data);
}
@@ -310,6 +507,10 @@ automaton::State api<automaton::State>::parse(std::list<sax::Token>& input) {
return FromXMLParsers::automatonParser.parseState(input);
}
+bool api<automaton::State>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_STATE);
+}
+
std::list<sax::Token> api<automaton::State>::compose(const automaton::State& data) {
return ToXMLComposers::automatonComposer.compose(data);
}
@@ -319,6 +520,10 @@ grammar::Grammar api<grammar::Grammar>::parse(std::list<sax::Token>& input) {
return FromXMLParsers::grammarParser.parseGrammar(input);
}
+bool api<grammar::Grammar>::first(const std::list<sax::Token>& input) {
+ return FromXMLParsers::grammarParser.first(input);
+}
+
std::list<sax::Token> api<grammar::Grammar>::compose(const grammar::Grammar& data) {
return ToXMLComposers::grammarComposer.compose(data);
}
@@ -327,6 +532,10 @@ grammar::LeftLG api<grammar::LeftLG>::parse(std::list<sax::Token>& input) {
return FromXMLParsers::grammarParser.parseLeftLG(input);
}
+bool api<grammar::LeftLG>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_LEFT_LG);
+}
+
std::list<sax::Token> api<grammar::LeftLG>::compose(const grammar::LeftLG& data) {
return ToXMLComposers::grammarComposer.compose(data);
}
@@ -335,6 +544,10 @@ grammar::LeftRG api<grammar::LeftRG>::parse(std::list<sax::Token>& input) {
return FromXMLParsers::grammarParser.parseLeftRG(input);
}
+bool api<grammar::LeftRG>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_LEFT_RG);
+}
+
std::list<sax::Token> api<grammar::LeftRG>::compose(const grammar::LeftRG& data) {
return ToXMLComposers::grammarComposer.compose(data);
}
@@ -343,6 +556,10 @@ grammar::RightLG api<grammar::RightLG>::parse(std::list<sax::Token>& input) {
return FromXMLParsers::grammarParser.parseRightLG(input);
}
+bool api<grammar::RightLG>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_RIGHT_LG);
+}
+
std::list<sax::Token> api<grammar::RightLG>::compose(const grammar::RightLG& data) {
return ToXMLComposers::grammarComposer.compose(data);
}
@@ -351,6 +568,10 @@ grammar::RightRG api<grammar::RightRG>::parse(std::list<sax::Token>& input) {
return FromXMLParsers::grammarParser.parseRightRG(input);
}
+bool api<grammar::RightRG>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_RIGHT_RG);
+}
+
std::list<sax::Token> api<grammar::RightRG>::compose(const grammar::RightRG& data) {
return ToXMLComposers::grammarComposer.compose(data);
}
@@ -359,6 +580,10 @@ grammar::LG api<grammar::LG>::parse(std::list<sax::Token>& input) {
return FromXMLParsers::grammarParser.parseLG(input);
}
+bool api<grammar::LG>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_LG);
+}
+
std::list<sax::Token> api<grammar::LG>::compose(const grammar::LG& data) {
return ToXMLComposers::grammarComposer.compose(data);
}
@@ -367,6 +592,10 @@ grammar::CFG api<grammar::CFG>::parse(std::list<sax::Token>& input) {
return FromXMLParsers::grammarParser.parseCFG(input);
}
+bool api<grammar::CFG>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_CFG);
+}
+
std::list<sax::Token> api<grammar::CFG>::compose(const grammar::CFG& data) {
return ToXMLComposers::grammarComposer.compose(data);
}
@@ -375,6 +604,10 @@ grammar::EpsilonFreeCFG api<grammar::EpsilonFreeCFG>::parse(std::list<sax::Token
return FromXMLParsers::grammarParser.parseEpsilonFreeCFG(input);
}
+bool api<grammar::EpsilonFreeCFG>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_EPSILON_FREE_CFG);
+}
+
std::list<sax::Token> api<grammar::EpsilonFreeCFG>::compose(const grammar::EpsilonFreeCFG& data) {
return ToXMLComposers::grammarComposer.compose(data);
}
@@ -383,6 +616,10 @@ grammar::CNF api<grammar::CNF>::parse(std::list<sax::Token>& input) {
return FromXMLParsers::grammarParser.parseCNF(input);
}
+bool api<grammar::CNF>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_CNF);
+}
+
std::list<sax::Token> api<grammar::CNF>::compose(const grammar::CNF& data) {
return ToXMLComposers::grammarComposer.compose(data);
}
@@ -391,6 +628,10 @@ grammar::GNF api<grammar::GNF>::parse(std::list<sax::Token>& input) {
return FromXMLParsers::grammarParser.parseGNF(input);
}
+bool api<grammar::GNF>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_GNF);
+}
+
std::list<sax::Token> api<grammar::GNF>::compose(const grammar::GNF& data) {
return ToXMLComposers::grammarComposer.compose(data);
}
@@ -399,6 +640,10 @@ grammar::CSG api<grammar::CSG>::parse(std::list<sax::Token>& input) {
return FromXMLParsers::grammarParser.parseCSG(input);
}
+bool api<grammar::CSG>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_CSG);
+}
+
std::list<sax::Token> api<grammar::CSG>::compose(const grammar::CSG& data) {
return ToXMLComposers::grammarComposer.compose(data);
}
@@ -407,6 +652,10 @@ grammar::NonContractingGrammar api<grammar::NonContractingGrammar>::parse(std::l
return FromXMLParsers::grammarParser.parseNonContractingGrammar(input);
}
+bool api<grammar::NonContractingGrammar>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_NON_CONTRACTING_GRAMMAR);
+}
+
std::list<sax::Token> api<grammar::NonContractingGrammar>::compose(const grammar::NonContractingGrammar& data) {
return ToXMLComposers::grammarComposer.compose(data);
}
@@ -415,6 +664,10 @@ grammar::ContextPreservingUnrestrictedGrammar api<grammar::ContextPreservingUnre
return FromXMLParsers::grammarParser.parseContextPreservingUnrestrictedGrammar(input);
}
+bool api<grammar::ContextPreservingUnrestrictedGrammar>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_CONTEXT_PRESERVING_UNRESTRICTED_GRAMMAR);
+}
+
std::list<sax::Token> api<grammar::ContextPreservingUnrestrictedGrammar>::compose(const grammar::ContextPreservingUnrestrictedGrammar& data) {
return ToXMLComposers::grammarComposer.compose(data);
}
@@ -423,6 +676,10 @@ grammar::UnrestrictedGrammar api<grammar::UnrestrictedGrammar>::parse(std::list<
return FromXMLParsers::grammarParser.parseUnrestrictedGrammar(input);
}
+bool api<grammar::UnrestrictedGrammar>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_UNRESTRICTED_GRAMMAR);
+}
+
std::list<sax::Token> api<grammar::UnrestrictedGrammar>::compose(const grammar::UnrestrictedGrammar& data) {
return ToXMLComposers::grammarComposer.compose(data);
}
@@ -432,6 +689,10 @@ label::Label api<label::Label>::parse(std::list<sax::Token>& input) {
return FromXMLParsers::labelParser.parseLabel(input);
}
+bool api<label::Label>::first(const std::list<sax::Token>& input) {
+ return FromXMLParsers::labelParser.first(input);
+}
+
std::list<sax::Token> api<label::Label>::compose(const label::Label& data) {
return ToXMLComposers::labelComposer.compose(data);
}
@@ -440,6 +701,10 @@ label::PrimitiveLabel api<label::PrimitiveLabel>::parse(std::list<sax::Token>& i
return FromXMLParsers::labelParser.parsePrimitiveLabel(input);
}
+bool api<label::PrimitiveLabel>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::LABEL_PRIMITIVE_LABEL);
+}
+
std::list<sax::Token> api<label::PrimitiveLabel>::compose(const label::PrimitiveLabel& data) {
return ToXMLComposers::labelComposer.compose(data);
}
@@ -448,6 +713,10 @@ label::HexavigesimalLabel api<label::HexavigesimalLabel>::parse(std::list<sax::T
return FromXMLParsers::labelParser.parseHexavigesimalLabel(input);
}
+bool api<label::HexavigesimalLabel>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::LABEL_PRIMITIVE_LABEL);
+}
+
std::list<sax::Token> api<label::HexavigesimalLabel>::compose(const label::HexavigesimalLabel& data) {
return ToXMLComposers::labelComposer.compose(data);
}
@@ -456,6 +725,10 @@ label::ObjectLabel api<label::ObjectLabel>::parse(std::list<sax::Token>& input)
return FromXMLParsers::labelParser.parseObjectLabel(input);
}
+bool api<label::ObjectLabel>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::LABEL_OBJECT_LABEL);
+}
+
std::list<sax::Token> api<label::ObjectLabel>::compose(const label::ObjectLabel& data) {
return ToXMLComposers::labelComposer.compose(data);
}
@@ -464,6 +737,10 @@ label::LabelSetLabel api<label::LabelSetLabel>::parse(std::list<sax::Token>& inp
return FromXMLParsers::labelParser.parseLabelSetLabel(input);
}
+bool api<label::LabelSetLabel>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::LABEL_LABEL_SET_LABEL);
+}
+
std::list<sax::Token> api<label::LabelSetLabel>::compose(const label::LabelSetLabel& data) {
return ToXMLComposers::labelComposer.compose(data);
}
@@ -472,6 +749,10 @@ label::LabelPairLabel api<label::LabelPairLabel>::parse(std::list<sax::Token>& i
return FromXMLParsers::labelParser.parseLabelPairLabel(input);
}
+bool api<label::LabelPairLabel>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::LABEL_LABEL_PAIR_LABEL);
+}
+
std::list<sax::Token> api<label::LabelPairLabel>::compose(const label::LabelPairLabel& data) {
return ToXMLComposers::labelComposer.compose(data);
}
@@ -481,6 +762,10 @@ regexp::RegExp api<regexp::RegExp>::parse(std::list<sax::Token>& input) {
return FromXMLParsers::regexpParser.parseRegExp(input);
}
+bool api<regexp::RegExp>::first(const std::list<sax::Token>& input) {
+ return FromXMLParsers::regexpParser.first(input);
+}
+
std::list<sax::Token> api<regexp::RegExp>::compose(const regexp::RegExp& data) {
return ToXMLComposers::regexpComposer.compose(data);
}
@@ -489,6 +774,10 @@ regexp::UnboundedRegExp api<regexp::UnboundedRegExp>::parse(std::list<sax::Token
return FromXMLParsers::regexpParser.parseUnboundedRegExp(input);
}
+bool api<regexp::UnboundedRegExp>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::REGEXP_UNBOUNDED_REGEXP);
+}
+
std::list<sax::Token> api<regexp::UnboundedRegExp>::compose(const regexp::UnboundedRegExp& data) {
return ToXMLComposers::regexpComposer.compose(data);
}
@@ -497,6 +786,10 @@ regexp::FormalRegExp api<regexp::FormalRegExp>::parse(std::list<sax::Token>& inp
return FromXMLParsers::regexpParser.parseFormalRegExp(input);
}
+bool api<regexp::FormalRegExp>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::REGEXP_FORMAL_REGEXP);
+}
+
std::list<sax::Token> api<regexp::FormalRegExp>::compose(const regexp::FormalRegExp& data) {
return ToXMLComposers::regexpComposer.compose(data);
}
@@ -506,6 +799,10 @@ string::String api<string::String>::parse(std::list<sax::Token>& input) {
return FromXMLParsers::stringParser.parseString(input);
}
+bool api<string::String>::first(const std::list<sax::Token>& input) {
+ return FromXMLParsers::stringParser.first(input);
+}
+
std::list<sax::Token> api<string::String>::compose(const string::String& data) {
return ToXMLComposers::stringComposer.compose(data);
}
@@ -514,6 +811,10 @@ string::LinearString api<string::LinearString>::parse(std::list<sax::Token>& inp
return FromXMLParsers::stringParser.parseLinearString(input);
}
+bool api<string::LinearString>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::STRING_LINEAR_STRING);
+}
+
std::list<sax::Token> api<string::LinearString>::compose(const string::LinearString& data) {
return ToXMLComposers::stringComposer.compose(data);
}
@@ -522,6 +823,10 @@ string::CyclicString api<string::CyclicString>::parse(std::list<sax::Token>& inp
return FromXMLParsers::stringParser.parseCyclicString(input);
}
+bool api<string::CyclicString>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::STRING_CYCLIC_STRING);
+}
+
std::list<sax::Token> api<string::CyclicString>::compose(const string::CyclicString& data) {
return ToXMLComposers::stringComposer.compose(data);
}
@@ -530,6 +835,10 @@ string::Epsilon api<string::Epsilon>::parse(std::list<sax::Token>& input) {
return FromXMLParsers::stringParser.parseEpsilon(input);
}
+bool api<string::Epsilon>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::STRING_EPSILON);
+}
+
std::list<sax::Token> api<string::Epsilon>::compose(const string::Epsilon& data) {
return ToXMLComposers::stringComposer.compose(data);
}
@@ -539,6 +848,10 @@ primitive::Primitive api<primitive::Primitive>::parse(std::list<sax::Token>& inp
return FromXMLParsers::primitiveParser.parsePrimitive(input);
}
+bool api<primitive::Primitive>::first(const std::list<sax::Token>& input) {
+ return FromXMLParsers::primitiveParser.first(input);
+}
+
std::list<sax::Token> api<primitive::Primitive>::compose(const primitive::Primitive& data) {
return ToXMLComposers::primitiveComposer.compose(data);
}
@@ -547,6 +860,10 @@ primitive::String api<primitive::String>::parse(std::list<sax::Token>& input) {
return FromXMLParsers::primitiveParser.parseString(input);
}
+bool api<primitive::String>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_STRING);
+}
+
std::list<sax::Token> api<primitive::String>::compose(const primitive::String& data) {
return ToXMLComposers::primitiveComposer.compose(data);
}
@@ -555,6 +872,10 @@ std::string api<std::string>::parse(std::list<sax::Token>& input) {
return FromXMLParsers::primitiveParser.parseStringRaw(input);
}
+bool api<std::string>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_STRING);
+}
+
std::list<sax::Token> api<std::string>::compose(const std::string& data) {
return ToXMLComposers::primitiveComposer.compose(data);
}
@@ -563,6 +884,10 @@ primitive::Integer api<primitive::Integer>::parse(std::list<sax::Token>& input)
return FromXMLParsers::primitiveParser.parseInteger(input);
}
+bool api<primitive::Integer>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_INTEGER);
+}
+
std::list<sax::Token> api<primitive::Integer>::compose(const primitive::Integer& data) {
return ToXMLComposers::primitiveComposer.compose(data);
}
@@ -571,6 +896,10 @@ int api<int>::parse(std::list<sax::Token>& input) {
return FromXMLParsers::primitiveParser.parseIntegerRaw(input);
}
+bool api<int>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_INTEGER);
+}
+
std::list<sax::Token> api<int>::compose(int data) {
return ToXMLComposers::primitiveComposer.compose(data);
}
@@ -579,6 +908,10 @@ primitive::Character api<primitive::Character>::parse(std::list<sax::Token>& inp
return FromXMLParsers::primitiveParser.parseCharacter(input);
}
+bool api<primitive::Character>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_CHARACTER);
+}
+
std::list<sax::Token> api<primitive::Character>::compose(const primitive::Character& data) {
return ToXMLComposers::primitiveComposer.compose(data);
}
@@ -587,6 +920,10 @@ char api<char>::parse(std::list<sax::Token>& input) {
return FromXMLParsers::primitiveParser.parseCharacterRaw(input);
}
+bool api<char>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_CHARACTER);
+}
+
std::list<sax::Token> api<char>::compose(char data) {
return ToXMLComposers::primitiveComposer.compose(data);
}
@@ -595,6 +932,10 @@ unsigned api<unsigned>::parse(std::list<sax::Token>& input) {
return FromXMLParsers::primitiveParser.parseCharacterRaw(input);
}
+bool api<unsigned>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_CHARACTER);
+}
+
std::list<sax::Token> api<unsigned>::compose(unsigned data) {
return ToXMLComposers::primitiveComposer.compose(data);
}
@@ -603,6 +944,10 @@ bool api<bool>::parse(std::list<sax::Token>& input) {
return FromXMLParsers::primitiveParser.parseCharacterRaw(input);
}
+bool api<bool>::first(const std::list<sax::Token>& input) {
+ return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_CHARACTER);
+}
+
std::list<sax::Token> api<bool>::compose(bool data) {
return ToXMLComposers::primitiveComposer.compose(data);
}
diff --git a/alib2data/src/Api.hpp b/alib2data/src/Api.hpp
index 6c7046cc47fc2d72ee2184d178c27d0b0e6af86e..bb6db4492319896ff0fc689e6cdc663c76dc6f9c 100644
--- a/alib2data/src/Api.hpp
+++ b/alib2data/src/Api.hpp
@@ -32,63 +32,138 @@
namespace alib {
+class Names {
+public:
+ const static std::string ALIB_VOID;
+ const static std::string CONTAINER_OBJECTS_SET;
+ const static std::string CONTAINER_OBJECTS_VECTOR;
+ const static std::string CONTAINER_OBJECTS_PAIR;
+ const static std::string CONTAINER_OBJECTS_MAP;
+ const static std::string EXCEPTION_ALIB_EXCEPTION;
+ const static std::string ALPHABET_LABELED_SYMBOL;
+ const static std::string ALPHABET_BLANK_SYMBOL;
+ const static std::string ALPHABET_BOTTOM_OF_THE_STACK_SYMBOL;
+ const static std::string ALPHABET_END_SYMBOL;
+ const static std::string ALPHABET_RANKED_SYMBOL;
+ const static std::string ALPHABET_BAR_SYMBOL;
+ const static std::string ALPHABET_RANKED_BAR_SYMBOL;
+ const static std::string ALPHABET_SUBTREE_WILDCARD_SYMBOL;
+ const static std::string AUTOMATON_EPSILON_NFA;
+ const static std::string AUTOMATON_MULTI_INITIAL_STATE_NFA;
+ const static std::string AUTOMATON_NFA;
+ const static std::string AUTOMATON_DFA;
+ const static std::string AUTOMATON_EXTENDED_NFA;
+ const static std::string AUTOMATON_COMPACT_NFA;
+ const static std::string AUTOMATON_DPDA;
+ const static std::string AUTOMATON_SINGLE_POP_DPDA;
+ const static std::string AUTOMATON_INPUT_DRIVEN_NPDA;
+ const static std::string AUTOMATON_VISIBLY_PUSHDOWN_DPDA;
+ const static std::string AUTOMATON_VISIBLY_PUSHDOWN_NPDA;
+ const static std::string AUTOMATON_REAL_TIME_HEIGHT_DETERMINISTIC_DPDA;
+ const static std::string AUTOMATON_REAL_TIME_HEIGHT_DETERMINISTIC_NPDA;
+ const static std::string AUTOMATON_NPDA;
+ const static std::string AUTOMATON_SINGLE_POP_NPDA;
+ const static std::string AUTOMATON_ONE_TAPE_DTM;
+ const static std::string AUTOMATON_STATE;
+ const static std::string GRAMMAR_LEFT_LG;
+ const static std::string GRAMMAR_LEFT_RG;
+ const static std::string GRAMMAR_RIGHT_LG;
+ const static std::string GRAMMAR_RIGHT_RG;
+ const static std::string GRAMMAR_LG;
+ const static std::string GRAMMAR_CFG;
+ const static std::string GRAMMAR_EPSILON_FREE_CFG;
+ const static std::string GRAMMAR_CNF;
+ const static std::string GRAMMAR_GNF;
+ const static std::string GRAMMAR_CSG;
+ const static std::string GRAMMAR_NON_CONTRACTING_GRAMMAR;
+ const static std::string GRAMMAR_CONTEXT_PRESERVING_UNRESTRICTED_GRAMMAR;
+ const static std::string GRAMMAR_UNRESTRICTED_GRAMMAR;
+ const static std::string LABEL_PRIMITIVE_LABEL;
+ const static std::string LABEL_HEXAVIGESIMAL_LABEL;
+ const static std::string LABEL_OBJECT_LABEL;
+ const static std::string LABEL_LABEL_SET_LABEL;
+ const static std::string LABEL_LABEL_PAIR_LABEL;
+ const static std::string REGEXP_UNBOUNDED_REGEXP;
+ const static std::string REGEXP_FORMAL_REGEXP;
+ const static std::string STRING_LINEAR_STRING;
+ const static std::string STRING_CYCLIC_STRING;
+ const static std::string STRING_EPSILON;
+ const static std::string PRIMITIVE_PRIMITIVE;
+ const static std::string PRIMITIVE_STRING;
+ const static std::string PRIMITIVE_INTEGER;
+ const static std::string PRIMITIVE_CHARACTER;
+ const static std::string PRIMITIVE_UNSIGNED;
+ const static std::string PRIMITIVE_BOOL;
+
+};
+
template<typename T>
struct api {
static T parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const T& data);
};
template<>
struct api<Void> {
static Void parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const Void& data);
};
template<typename T>
struct api<std::set<T>> {
static std::set<T> parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const std::set<T>& data);
};
template<>
struct api<container::ObjectsSet> {
static container::ObjectsSet parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const container::ObjectsSet& data);
};
template<typename T>
struct api<std::vector<T>> {
static std::vector<T> parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const std::vector<T>& data);
};
template<>
struct api<container::ObjectsVector> {
static container::ObjectsVector parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const container::ObjectsVector& data);
};
template<typename T, typename R>
struct api<std::pair<T, R>> {
static std::pair<T, R> parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const std::pair<T, R>& data);
};
template<>
struct api<container::ObjectsPair> {
static container::ObjectsPair parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const container::ObjectsPair& data);
};
template<typename T, typename R>
struct api<std::map<T, R>> {
static std::map<T, R> parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const std::map<T, R>& data);
};
template<>
struct api<container::ObjectsMap> {
static container::ObjectsMap parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const container::ObjectsMap& data);
};
@@ -96,6 +171,7 @@ struct api<container::ObjectsMap> {
template<>
struct api<Object> {
static Object parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const Object& data);
};
@@ -103,6 +179,7 @@ struct api<Object> {
template<>
struct api<exception::AlibException> {
static exception::AlibException parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const exception::AlibException& data);
};
@@ -110,30 +187,35 @@ struct api<exception::AlibException> {
template<>
struct api<alphabet::Symbol> {
static alphabet::Symbol parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const alphabet::Symbol& data);
};
template<>
struct api<alphabet::LabeledSymbol> {
static alphabet::LabeledSymbol parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const alphabet::LabeledSymbol& data);
};
template<>
struct api<alphabet::BlankSymbol> {
static alphabet::BlankSymbol parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const alphabet::BlankSymbol& data);
};
template<>
struct api<alphabet::BottomOfTheStackSymbol> {
static alphabet::BottomOfTheStackSymbol parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const alphabet::BottomOfTheStackSymbol& data);
};
template<>
struct api<alphabet::EndSymbol> {
static alphabet::EndSymbol parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const alphabet::EndSymbol& data);
};
@@ -141,216 +223,252 @@ struct api<alphabet::EndSymbol> {
template<>
struct api<alphabet::RankedSymbol> {
static alphabet::RankedSymbol parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const alphabet::RankedSymbol& data);
};
template<>
struct api<alphabet::BarSymbol> {
static alphabet::BarSymbol parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const alphabet::BarSymbol& data);
};
template<>
struct api<alphabet::RankedBarSymbol> {
static alphabet::RankedBarSymbol parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const alphabet::RankedBarSymbol& data);
};
template<>
struct api<alphabet::SubtreeWildcardSymbol> {
static alphabet::SubtreeWildcardSymbol parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const alphabet::SubtreeWildcardSymbol& data);
};
template<>
struct api<automaton::Automaton> {
static automaton::Automaton parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const automaton::Automaton& data);
};
template<>
struct api<automaton::EpsilonNFA> {
static automaton::EpsilonNFA parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const automaton::EpsilonNFA& data);
};
template<>
struct api<automaton::MultiInitialStateNFA> {
static automaton::MultiInitialStateNFA parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const automaton::MultiInitialStateNFA& data);
};
template<>
struct api<automaton::NFA> {
static automaton::NFA parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const automaton::NFA& data);
};
template<>
struct api<automaton::DFA> {
static automaton::DFA parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const automaton::DFA& data);
};
template<>
struct api<automaton::ExtendedNFA> {
static automaton::ExtendedNFA parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const automaton::ExtendedNFA& data);
};
template<>
struct api<automaton::CompactNFA> {
static automaton::CompactNFA parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const automaton::CompactNFA& data);
};
template<>
struct api<automaton::DPDA> {
static automaton::DPDA parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const automaton::DPDA& data);
};
template<>
struct api<automaton::SinglePopDPDA> {
static automaton::SinglePopDPDA parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const automaton::SinglePopDPDA& data);
};
template<>
struct api<automaton::InputDrivenNPDA> {
static automaton::InputDrivenNPDA parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const automaton::InputDrivenNPDA& data);
};
template<>
struct api<automaton::VisiblyPushdownDPDA> {
static automaton::VisiblyPushdownDPDA parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const automaton::VisiblyPushdownDPDA& data);
};
template<>
struct api<automaton::VisiblyPushdownNPDA> {
static automaton::VisiblyPushdownNPDA parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const automaton::VisiblyPushdownNPDA& data);
};
template<>
struct api<automaton::RealTimeHeightDeterministicDPDA> {
static automaton::RealTimeHeightDeterministicDPDA parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const automaton::RealTimeHeightDeterministicDPDA& data);
};
template<>
struct api<automaton::RealTimeHeightDeterministicNPDA> {
static automaton::RealTimeHeightDeterministicNPDA parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const automaton::RealTimeHeightDeterministicNPDA& data);
};
template<>
struct api<automaton::NPDA> {
static automaton::NPDA parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const automaton::NPDA& data);
};
template<>
struct api<automaton::SinglePopNPDA> {
static automaton::SinglePopNPDA parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const automaton::SinglePopNPDA& data);
};
template<>
struct api<automaton::OneTapeDTM> {
static automaton::OneTapeDTM parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const automaton::OneTapeDTM& data);
};
template<>
struct api<automaton::State> {
static automaton::State parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const automaton::State& data);
};
template<>
struct api<grammar::Grammar> {
static grammar::Grammar parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const grammar::Grammar& data);
};
template<>
struct api<grammar::LeftLG> {
static grammar::LeftLG parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const grammar::LeftLG& data);
};
template<>
struct api<grammar::LeftRG> {
static grammar::LeftRG parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const grammar::LeftRG& data);
};
template<>
struct api<grammar::RightLG> {
static grammar::RightLG parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const grammar::RightLG& data);
};
template<>
struct api<grammar::RightRG> {
static grammar::RightRG parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const grammar::RightRG& data);
};
template<>
struct api<grammar::LG> {
static grammar::LG parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const grammar::LG& data);
};
template<>
struct api<grammar::CFG> {
static grammar::CFG parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const grammar::CFG& data);
};
template<>
struct api<grammar::EpsilonFreeCFG> {
static grammar::EpsilonFreeCFG parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const grammar::EpsilonFreeCFG& data);
};
template<>
struct api<grammar::CNF> {
static grammar::CNF parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const grammar::CNF& data);
};
template<>
struct api<grammar::GNF> {
static grammar::GNF parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const grammar::GNF& data);
};
template<>
struct api<grammar::CSG> {
static grammar::CSG parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const grammar::CSG& data);
};
template<>
struct api<grammar::NonContractingGrammar> {
static grammar::NonContractingGrammar parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const grammar::NonContractingGrammar& data);
};
template<>
struct api<grammar::ContextPreservingUnrestrictedGrammar> {
static grammar::ContextPreservingUnrestrictedGrammar parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const grammar::ContextPreservingUnrestrictedGrammar& data);
};
template<>
struct api<grammar::UnrestrictedGrammar> {
static grammar::UnrestrictedGrammar parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const grammar::UnrestrictedGrammar& data);
};
@@ -358,36 +476,42 @@ struct api<grammar::UnrestrictedGrammar> {
template<>
struct api<label::Label> {
static label::Label parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const label::Label& data);
};
template<>
struct api<label::PrimitiveLabel> {
static label::PrimitiveLabel parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const label::PrimitiveLabel& data);
};
template<>
struct api<label::HexavigesimalLabel> {
static label::HexavigesimalLabel parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const label::HexavigesimalLabel& data);
};
template<>
struct api<label::ObjectLabel> {
static label::ObjectLabel parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const label::ObjectLabel& data);
};
template<>
struct api<label::LabelSetLabel> {
static label::LabelSetLabel parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const label::LabelSetLabel& data);
};
template<>
struct api<label::LabelPairLabel> {
static label::LabelPairLabel parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const label::LabelPairLabel& data);
};
@@ -395,18 +519,21 @@ struct api<label::LabelPairLabel> {
template<>
struct api<regexp::RegExp> {
static regexp::RegExp parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const regexp::RegExp& data);
};
template<>
struct api<regexp::UnboundedRegExp> {
static regexp::UnboundedRegExp parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const regexp::UnboundedRegExp& data);
};
template<>
struct api<regexp::FormalRegExp> {
static regexp::FormalRegExp parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const regexp::FormalRegExp& data);
};
@@ -414,24 +541,28 @@ struct api<regexp::FormalRegExp> {
template<>
struct api<string::String> {
static string::String parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const string::String& data);
};
template<>
struct api<string::LinearString> {
static string::LinearString parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const string::LinearString& data);
};
template<>
struct api<string::CyclicString> {
static string::CyclicString parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const string::CyclicString& data);
};
template<>
struct api<string::Epsilon> {
static string::Epsilon parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const string::Epsilon& data);
};
@@ -439,54 +570,63 @@ struct api<string::Epsilon> {
template<>
struct api<primitive::Primitive> {
static primitive::Primitive parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const primitive::Primitive& data);
};
template<>
struct api<primitive::String> {
static primitive::String parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const primitive::String& data);
};
template<>
struct api<std::string> {
static std::string parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const std::string& data);
};
template<>
struct api<primitive::Integer> {
static primitive::Integer parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const primitive::Integer& data);
};
template<>
struct api<int> {
static int parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(int data);
};
template<>
struct api<primitive::Character> {
static primitive::Character parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const primitive::Character& data);
};
template<>
struct api<char> {
static char parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(char data);
};
template<>
struct api<unsigned> {
static unsigned parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(unsigned data);
};
template<>
struct api<bool> {
static bool parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(bool data);
};
@@ -501,6 +641,7 @@ namespace alib {
template<>
struct api<container::Container> {
static container::Container parse(std::list<sax::Token>& input);
+ static bool first(const std::list<sax::Token>& input);
static std::list<sax::Token> compose(const container::Container& data);
};
@@ -610,6 +751,11 @@ std::set<T> api<std::set<T>>::parse(std::list<sax::Token>& input) {
return FromXMLParsers::containerParser.parseSet<T>(input);
}
+template<typename T>
+bool api<std::set<T>>::first(const std::list<sax::Token>& input) {
+ return input.front().getType() == sax::Token::TokenType::START_ELEMENT && input.front().getData() == Names::CONTAINER_OBJECTS_SET;
+}
+
template<typename T>
std::list<sax::Token> api<std::set<T>>::compose(const std::set<T>& input) {
return ToXMLComposers::containerComposer.compose<T>(input);
@@ -620,6 +766,11 @@ std::vector<T> api<std::vector<T>>::parse(std::list<sax::Token>& input) {
return FromXMLParsers::containerParser.parseVector<T>(input);
}
+template<typename T>
+bool api<std::vector<T>>::first(const std::list<sax::Token>& input) {
+ return input.front().getType() == sax::Token::TokenType::START_ELEMENT && input.front().getData() == Names::CONTAINER_OBJECTS_VECTOR;
+}
+
template<typename T>
std::list<sax::Token> api<std::vector<T>>::compose(const std::vector<T>& input) {
return ToXMLComposers::containerComposer.compose<T>(input);
@@ -630,6 +781,11 @@ std::pair<T, R> api<std::pair<T, R>>::parse(std::list<sax::Token>& input) {
return FromXMLParsers::containerParser.parsePair<T, R>(input);
}
+template<typename T, typename R>
+bool api<std::pair<T, R>>::first(const std::list<sax::Token>& input) {
+ return input.front().getType() == sax::Token::TokenType::START_ELEMENT && input.front().getData() == Names::CONTAINER_OBJECTS_PAIR;
+}
+
template<typename T, typename R>
std::list<sax::Token> api<std::pair<T, R>>::compose(const std::pair<T, R>& input) {
return ToXMLComposers::containerComposer.compose<T, R>(input);
@@ -640,6 +796,11 @@ std::map<T, R> api<std::map<T, R>>::parse(std::list<sax::Token>& input) {
return FromXMLParsers::containerParser.parseMap<T, R>(input);
}
+template<typename T, typename R>
+bool api<std::map<T, R>>::first(const std::list<sax::Token>& input) {
+ return input.front().getType() == sax::Token::TokenType::START_ELEMENT && input.front().getData() == Names::CONTAINER_OBJECTS_MAP;
+}
+
template<typename T, typename R>
std::list<sax::Token> api<std::map<T, R>>::compose(const std::map<T, R>& input) {
return ToXMLComposers::containerComposer.compose<T, R>(input);
diff --git a/alib2data/src/alphabet/SymbolFromXMLParser.cpp b/alib2data/src/alphabet/SymbolFromXMLParser.cpp
index 69356b756dd5d76d091ce050fbcbf2c8f86157f4..2faa352f8754b20bc7416e5a06ef9c0a93694b4a 100644
--- a/alib2data/src/alphabet/SymbolFromXMLParser.cpp
+++ b/alib2data/src/alphabet/SymbolFromXMLParser.cpp
@@ -19,28 +19,28 @@ Symbol SymbolFromXMLParser::parseSymbol(std::list<sax::Token>& input) const {
}
Symbol SymbolFromXMLParser::parseSymbol(std::list<sax::Token>& input, const std::set<FEATURES>& features) const {
- if(isToken(input, sax::Token::TokenType::START_ELEMENT, "LabeledSymbol")) {
+ if(alib::api<LabeledSymbol>::first(input)) {
if(!features.count(FEATURES::LABELED)) throw exception::AlibException();
return Symbol(parseLabeledSymbol(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "BlankSymbol")) {
+ } else if(alib::api<BlankSymbol>::first(input)) {
if(!features.count(FEATURES::BLANK)) throw exception::AlibException();
return Symbol(parseBlankSymbol(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "BottomOfTheStackSymbol")) {
+ } else if(alib::api<BottomOfTheStackSymbol>::first(input)) {
if(!features.count(FEATURES::BOTTOM)) throw exception::AlibException();
return Symbol(parseBottomOfTheStackSymbol(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "EndSymbol")) {
+ } else if(alib::api<EndSymbol>::first(input)) {
if(!features.count(FEATURES::END)) throw exception::AlibException();
return Symbol(parseEndSymbol(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "RankedSymbol")) {
+ } else if(alib::api<RankedSymbol>::first(input)) {
if(!features.count(FEATURES::RANKED)) throw exception::AlibException();
return Symbol(parseRankedSymbol(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "BarSymbol")) {
+ } else if(alib::api<BarSymbol>::first(input)) {
if(!features.count(FEATURES::BAR)) throw exception::AlibException();
return Symbol(parseBarSymbol(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "RankedBarSymbol")) {
+ } else if(alib::api<RankedBarSymbol>::first(input)) {
if(!features.count(FEATURES::RANKED_BAR)) throw exception::AlibException();
return Symbol(parseRankedBarSymbol(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "SubtreeWildcardSymbol")) {
+ } else if(alib::api<SubtreeWildcardSymbol>::first(input)) {
if(!features.count(FEATURES::SUBTREE_WILDCARD)) throw exception::AlibException();
return Symbol(parseSubtreeWildcardSymbol(input));
} else {
@@ -48,8 +48,8 @@ Symbol SymbolFromXMLParser::parseSymbol(std::list<sax::Token>& input, const std:
}
}
-bool SymbolFromXMLParser::first(std::list<sax::Token>& input) const {
- if(isToken(input, sax::Token::TokenType::START_ELEMENT, "LabeledSymbol") || isToken(input, sax::Token::TokenType::START_ELEMENT, "BlankSymbol") || isToken(input, sax::Token::TokenType::START_ELEMENT, "BottomOfTheStackSymbol") || isToken(input, sax::Token::TokenType::START_ELEMENT, "EndSymbol") || isToken(input, sax::Token::TokenType::START_ELEMENT, "RankedSymbol") || isToken(input, sax::Token::TokenType::START_ELEMENT, "BarSymbol") || isToken(input, sax::Token::TokenType::START_ELEMENT, "RankedBarSymbol") || isToken(input, sax::Token::TokenType::START_ELEMENT, "SubtreeWildcardSymbol")) {
+bool SymbolFromXMLParser::first(const std::list<sax::Token>& input) const {
+ if(alib::api<LabeledSymbol>::first(input) || alib::api<BlankSymbol>::first(input) || alib::api<BottomOfTheStackSymbol>::first(input) || alib::api<EndSymbol>::first(input) || alib::api<RankedSymbol>::first(input) || alib::api<BarSymbol>::first(input) || alib::api<RankedBarSymbol>::first(input) || alib::api<SubtreeWildcardSymbol>::first(input)) {
return true;
} else {
return false;
@@ -57,54 +57,54 @@ bool SymbolFromXMLParser::first(std::list<sax::Token>& input) const {
}
LabeledSymbol SymbolFromXMLParser::parseLabeledSymbol(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "LabeledSymbol");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALPHABET_LABELED_SYMBOL);
label::Label data = alib::api<label::Label>::parse(input);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "LabeledSymbol");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_LABELED_SYMBOL);
return LabeledSymbol(data);
}
BlankSymbol SymbolFromXMLParser::parseBlankSymbol(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "BlankSymbol");
- popToken(input, sax::Token::TokenType::END_ELEMENT, "BlankSymbol");
+ 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::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "BottomOfTheStackSymbol");
- popToken(input, sax::Token::TokenType::END_ELEMENT, "BottomOfTheStackSymbol");
+ 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::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "EndSymbol");
- popToken(input, sax::Token::TokenType::END_ELEMENT, "EndSymbol");
+ 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();
}
RankedSymbol SymbolFromXMLParser::parseRankedSymbol(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "RankedSymbol");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALPHABET_RANKED_SYMBOL);
label::Label data = alib::api<label::Label>::parse(input);
primitive::Integer rank = alib::api<primitive::Integer>::parse(input);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "RankedSymbol");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_RANKED_SYMBOL);
return RankedSymbol(data, rank);
}
BarSymbol SymbolFromXMLParser::parseBarSymbol(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "BarSymbol");
- popToken(input, sax::Token::TokenType::END_ELEMENT, "BarSymbol");
+ 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();
}
RankedBarSymbol SymbolFromXMLParser::parseRankedBarSymbol(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "RankedBarSymbol");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALPHABET_RANKED_BAR_SYMBOL);
primitive::Integer rank = alib::api<primitive::Integer>::parse(input);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "RankedBarSymbol");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_RANKED_BAR_SYMBOL);
return RankedBarSymbol(rank);
}
SubtreeWildcardSymbol SymbolFromXMLParser::parseSubtreeWildcardSymbol(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "SubtreeWildcardSymbol");
- popToken(input, sax::Token::TokenType::END_ELEMENT, "SubtreeWildcardSymbol");
+ 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();
}
diff --git a/alib2data/src/alphabet/SymbolFromXMLParser.h b/alib2data/src/alphabet/SymbolFromXMLParser.h
index 49a7d4ac30650a4f1e1d1b308c49e878473ee6f1..c0b6d20db13e4a84be82bec31b56102bf0dd1c27 100644
--- a/alib2data/src/alphabet/SymbolFromXMLParser.h
+++ b/alib2data/src/alphabet/SymbolFromXMLParser.h
@@ -52,7 +52,7 @@ class SymbolFromXMLParser : public sax::FromXMLParserHelper {
template<typename T> friend class alib::api;
public:
- bool first(std::list<sax::Token>& input) const;
+ bool first(const std::list<sax::Token>& input) const;
};
} /* namespace alphabet */
diff --git a/alib2data/src/alphabet/SymbolToXMLComposer.cpp b/alib2data/src/alphabet/SymbolToXMLComposer.cpp
index 7c5f4e14d369dc2b332ed811a5157ff52fa52dbf..b3ef0a2025e1dab5eb1fe288624b5fe42b00ac1a 100644
--- a/alib2data/src/alphabet/SymbolToXMLComposer.cpp
+++ b/alib2data/src/alphabet/SymbolToXMLComposer.cpp
@@ -25,61 +25,61 @@ std::list<sax::Token> SymbolToXMLComposer::compose(const SymbolBase& symbol) con
std::list<sax::Token> SymbolToXMLComposer::compose(const LabeledSymbol& symbol) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("LabeledSymbol", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::ALPHABET_LABELED_SYMBOL, sax::Token::TokenType::START_ELEMENT));
out.splice(out.end(), alib::api<label::Label>::compose(symbol.getLabel()));
- out.push_back(sax::Token("LabeledSymbol", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::ALPHABET_LABELED_SYMBOL, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> SymbolToXMLComposer::compose(const BlankSymbol&) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("BlankSymbol", sax::Token::TokenType::START_ELEMENT));
- out.push_back(sax::Token("BlankSymbol", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::ALPHABET_BLANK_SYMBOL, sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::ALPHABET_BLANK_SYMBOL, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> SymbolToXMLComposer::compose(const BottomOfTheStackSymbol&) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("BottomOfTheStackSymbol", sax::Token::TokenType::START_ELEMENT));
- out.push_back(sax::Token("BottomOfTheStackSymbol", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::ALPHABET_BOTTOM_OF_THE_STACK_SYMBOL, sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::ALPHABET_BOTTOM_OF_THE_STACK_SYMBOL, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> SymbolToXMLComposer::compose(const EndSymbol&) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("EndSymbol", sax::Token::TokenType::START_ELEMENT));
- out.push_back(sax::Token("EndSymbol", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::ALPHABET_END_SYMBOL, sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::ALPHABET_END_SYMBOL, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> SymbolToXMLComposer::compose(const RankedSymbol& symbol) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("RankedSymbol", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::ALPHABET_RANKED_SYMBOL, sax::Token::TokenType::START_ELEMENT));
out.splice(out.end(), alib::api<label::Label>::compose(symbol.getLabel()));
out.splice(out.end(), alib::api<primitive::Integer>::compose(symbol.getRank()));
- out.push_back(sax::Token("RankedSymbol", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::ALPHABET_RANKED_SYMBOL, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> SymbolToXMLComposer::compose(const BarSymbol&) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("BarSymbol", sax::Token::TokenType::START_ELEMENT));
- out.push_back(sax::Token("BarSymbol", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::ALPHABET_BAR_SYMBOL, sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::ALPHABET_BAR_SYMBOL, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> SymbolToXMLComposer::compose(const RankedBarSymbol& symbol) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("RankedBarSymbol", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::ALPHABET_RANKED_BAR_SYMBOL, sax::Token::TokenType::START_ELEMENT));
out.splice(out.end(), alib::api<primitive::Integer>::compose(symbol.getRank()));
- out.push_back(sax::Token("RankedBarSymbol", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::ALPHABET_RANKED_BAR_SYMBOL, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> SymbolToXMLComposer::compose(const SubtreeWildcardSymbol&) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("SubtreeWildcardSymbol", sax::Token::TokenType::START_ELEMENT));
- out.push_back(sax::Token("SubtreeWildcardSymbol", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::ALPHABET_SUBTREE_WILDCARD_SYMBOL, sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::ALPHABET_SUBTREE_WILDCARD_SYMBOL, sax::Token::TokenType::END_ELEMENT));
return out;
}
diff --git a/alib2data/src/automaton/AutomatonFromXMLParser.cpp b/alib2data/src/automaton/AutomatonFromXMLParser.cpp
index f160633e106a4ba86e3cd1d7092b7753beca8d89..b54b892fc79fd499be7f7d31b72e6f6fa57f0876 100644
--- a/alib2data/src/automaton/AutomatonFromXMLParser.cpp
+++ b/alib2data/src/automaton/AutomatonFromXMLParser.cpp
@@ -20,60 +20,60 @@ Automaton AutomatonFromXMLParser::parseAutomaton(std::list<sax::Token> &input) c
}
Automaton AutomatonFromXMLParser::parseAutomaton(std::list<sax::Token>& input, const std::set<FEATURES>& features) const {
- if(isToken(input, sax::Token::TokenType::START_ELEMENT, "EpsilonNFA")) {
+ if(alib::api<EpsilonNFA>::first(input)) {
if(!features.count(FEATURES::EPSILON_NFA)) throw exception::AlibException();
return Automaton(parseEpsilonNFA(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "MultiInitialStateNFA")) {
+ } else if(alib::api<MultiInitialStateNFA>::first(input)) {
if(!features.count(FEATURES::MULTI_INITIAL_STATE_NFA)) throw exception::AlibException();
return Automaton(parseMultiInitialStateNFA(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "NFA")) {
+ } else if(alib::api<NFA>::first(input)) {
if(!features.count(FEATURES::NFA)) throw exception::AlibException();
return Automaton(parseNFA(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "DFA")) {
+ } else if(alib::api<DFA>::first(input)) {
if(!features.count(FEATURES::DFA)) throw exception::AlibException();
return Automaton(parseDFA(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "CompactNFA")) {
+ } else if(alib::api<CompactNFA>::first(input)) {
if(!features.count(FEATURES::COMPACT_NFA)) throw exception::AlibException();
return Automaton(parseCompactNFA(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "ExtendedNFA")) {
+ } else if(alib::api<ExtendedNFA>::first(input)) {
if(!features.count(FEATURES::EXTENDED_NFA)) throw exception::AlibException();
return Automaton(parseExtendedNFA(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "DPDA")) {
+ } else if(alib::api<DPDA>::first(input)) {
if(!features.count(FEATURES::DPDA)) throw exception::AlibException();
return Automaton(parseDPDA(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "SinglePopDPDA")) {
+ } else if(alib::api<SinglePopDPDA>::first(input)) {
if(!features.count(FEATURES::SINGLE_POP_DPDA)) throw exception::AlibException();
return Automaton(parseSinglePopDPDA(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "InputDrivenNPDA")) {
+ } else if(alib::api<InputDrivenNPDA>::first(input)) {
if(!features.count(FEATURES::INPUT_DRIVEN_NPDA)) throw exception::AlibException();
return Automaton(parseInputDrivenNPDA(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "VisiblyPushdownDPDA")) {
+ } else if(alib::api<VisiblyPushdownDPDA>::first(input)) {
if(!features.count(FEATURES::VISIBLY_PUSHDOWN_DPDA)) throw exception::AlibException();
return Automaton(parseVisiblyPushdownDPDA(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "VisiblyPushdownNPDA")) {
+ } else if(alib::api<VisiblyPushdownNPDA>::first(input)) {
if(!features.count(FEATURES::VISIBLY_PUSHDOWN_NPDA)) throw exception::AlibException();
return Automaton(parseVisiblyPushdownNPDA(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "RealTimeHeightDeterministicDPDA")) {
+ } else if(alib::api<RealTimeHeightDeterministicDPDA>::first(input)) {
if(!features.count(FEATURES::REAL_TIME_HEIGHT_DETERMINISTIC_DPDA)) throw exception::AlibException();
return Automaton(parseRealTimeHeightDeterministicDPDA(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "RealTimeHeightDeterministicNPDA")) {
+ } else if(alib::api<RealTimeHeightDeterministicNPDA>::first(input)) {
if(!features.count(FEATURES::REAL_TIME_HEIGHT_DETERMINISTIC_NPDA)) throw exception::AlibException();
return Automaton(parseRealTimeHeightDeterministicNPDA(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "NPDA")) {
+ } else if(alib::api<NPDA>::first(input)) {
if(!features.count(FEATURES::NPDA)) throw exception::AlibException();
return Automaton(parseNPDA(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "SinglePopNPDA")) {
+ } else if(alib::api<SinglePopNPDA>::first(input)) {
if(!features.count(FEATURES::SINGLE_POP_NPDA)) throw exception::AlibException();
return Automaton(parseSinglePopNPDA(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "OneTapeDTM")) {
+ } else if(alib::api<OneTapeDTM>::first(input)) {
if(!features.count(FEATURES::ONE_TAPE_DTM)) throw exception::AlibException();
return Automaton(parseOneTapeDTM(input));
} else
throw sax::ParserException(sax::Token("Automaton / EpsilonNFA / NFA / DFA / CompactNFA / ExtendedNFA / DPDA / SinglePopDPDA / InputDrivenNPDA / VisiblyPushdownDPDA / VisiblyPushdownNPDA / RealTimeHeightDeterministicDPDA / RealTimeHeightDeterministicNPDA / NPDA / SinglePopNPDA / OneTapeDTM", sax::Token::TokenType::START_ELEMENT), input.front());
}
-bool AutomatonFromXMLParser::first(std::list<sax::Token>& input) const {
- if(isToken(input, sax::Token::TokenType::START_ELEMENT, "automaton") || isToken(input, sax::Token::TokenType::START_ELEMENT, "EpsilonNFA") || isToken(input, sax::Token::TokenType::START_ELEMENT, "NFA") || isToken(input, sax::Token::TokenType::START_ELEMENT, "DFA") || isToken(input, sax::Token::TokenType::START_ELEMENT, "CompactNFA") || isToken(input, sax::Token::TokenType::START_ELEMENT, "ExtendedNFA") || isToken(input, sax::Token::TokenType::START_ELEMENT, "DPDA") || isToken(input, sax::Token::TokenType::START_ELEMENT, "SinglePopDPDA") || isToken(input, sax::Token::TokenType::START_ELEMENT, "InputDrivenNPDA") || isToken(input, sax::Token::TokenType::START_ELEMENT, "VisiblyPushdownDPDA") || isToken(input, sax::Token::TokenType::START_ELEMENT, "VisiblyPushdownNPDA") || isToken(input, sax::Token::TokenType::START_ELEMENT, "RealTimeHeightDeterministicDPDA") || isToken(input, sax::Token::TokenType::START_ELEMENT, "RealTimeHeightDeterministicNPDA") || isToken(input, sax::Token::TokenType::START_ELEMENT, "NPDA") || isToken(input, sax::Token::TokenType::START_ELEMENT, "SinglePopNPDA") || isToken(input, sax::Token::TokenType::START_ELEMENT, "OneTapeDTM")) {
+bool AutomatonFromXMLParser::first(const std::list<sax::Token>& input) const {
+ if(alib::api<EpsilonNFA>::first(input) || alib::api<NFA>::first(input) || alib::api<DFA>::first(input) || alib::api<CompactNFA>::first(input) || alib::api<ExtendedNFA>::first(input) || alib::api<DPDA>::first(input) || alib::api<SinglePopDPDA>::first(input) || alib::api<InputDrivenNPDA>::first(input) || alib::api<VisiblyPushdownDPDA>::first(input) || alib::api<VisiblyPushdownNPDA>::first(input) || alib::api<RealTimeHeightDeterministicDPDA>::first(input) || alib::api<RealTimeHeightDeterministicNPDA>::first(input) || alib::api<NPDA>::first(input) || alib::api<SinglePopNPDA>::first(input) || alib::api<OneTapeDTM>::first(input)) {
return true;
} else {
return false;
@@ -90,7 +90,7 @@ void AutomatonFromXMLParser::parseTransitions(std::list<sax::Token> &input, T& a
}
DFA AutomatonFromXMLParser::parseDFA(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "DFA");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_DFA);
std::set<State> states = parseStates(input);
std::set<alphabet::Symbol> inputSymbols = parseInputAlphabet(input);
@@ -104,12 +104,12 @@ DFA AutomatonFromXMLParser::parseDFA(std::list<sax::Token>& input) const {
parseTransitions<DFA>(input, automaton);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "DFA");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::AUTOMATON_DFA);
return automaton;
}
NFA AutomatonFromXMLParser::parseNFA(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "NFA");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_NFA);
std::set<State> states = parseStates(input);
std::set<alphabet::Symbol> inputSymbols = parseInputAlphabet(input);
@@ -123,12 +123,12 @@ NFA AutomatonFromXMLParser::parseNFA(std::list<sax::Token>& input) const {
parseTransitions<NFA>(input, automaton);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "NFA");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::AUTOMATON_NFA);
return automaton;
}
MultiInitialStateNFA AutomatonFromXMLParser::parseMultiInitialStateNFA(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "MultiInitialStateNFA");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_MULTI_INITIAL_STATE_NFA);
std::set<State> states = parseStates(input);
std::set<alphabet::Symbol> inputSymbols = parseInputAlphabet(input);
@@ -143,12 +143,12 @@ MultiInitialStateNFA AutomatonFromXMLParser::parseMultiInitialStateNFA(std::list
parseTransitions<MultiInitialStateNFA>(input, automaton);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "MultiInitialStateNFA");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::AUTOMATON_MULTI_INITIAL_STATE_NFA);
return automaton;
}
EpsilonNFA AutomatonFromXMLParser::parseEpsilonNFA(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "EpsilonNFA");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_EPSILON_NFA);
std::set<State> states = parseStates(input);
std::set<alphabet::Symbol> inputSymbols = parseInputAlphabet(input);
@@ -162,12 +162,12 @@ EpsilonNFA AutomatonFromXMLParser::parseEpsilonNFA(std::list<sax::Token>& input)
parseTransitions<EpsilonNFA>(input, automaton);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "EpsilonNFA");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::AUTOMATON_EPSILON_NFA);
return automaton;
}
CompactNFA AutomatonFromXMLParser::parseCompactNFA(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "CompactNFA");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_COMPACT_NFA);
std::set<State> states = parseStates(input);
std::set<alphabet::Symbol> inputSymbols = parseInputAlphabet(input);
@@ -181,12 +181,12 @@ CompactNFA AutomatonFromXMLParser::parseCompactNFA(std::list<sax::Token>& input)
parseTransitions<CompactNFA>(input, automaton);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "CompactNFA");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::AUTOMATON_COMPACT_NFA);
return automaton;
}
ExtendedNFA AutomatonFromXMLParser::parseExtendedNFA(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "ExtendedNFA");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_EXTENDED_NFA);
std::set<State> states = parseStates(input);
std::set<alphabet::Symbol> inputSymbols = parseInputAlphabet(input);
@@ -200,12 +200,12 @@ ExtendedNFA AutomatonFromXMLParser::parseExtendedNFA(std::list<sax::Token>& inpu
parseTransitions<ExtendedNFA>(input, automaton);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "ExtendedNFA");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::AUTOMATON_EXTENDED_NFA);
return automaton;
}
DPDA AutomatonFromXMLParser::parseDPDA(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "DPDA");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_DPDA);
std::set<State> states = parseStates(input);
std::set<alphabet::Symbol> inputSymbols = parseInputAlphabet(input);
@@ -222,13 +222,13 @@ DPDA AutomatonFromXMLParser::parseDPDA(std::list<sax::Token>& input) const {
parseTransitions<DPDA>(input, automaton);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "DPDA");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::AUTOMATON_DPDA);
return automaton;
}
SinglePopDPDA AutomatonFromXMLParser::parseSinglePopDPDA(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "SinglePopDPDA");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_SINGLE_POP_DPDA);
std::set<State> states = parseStates(input);
std::set<alphabet::Symbol> inputSymbols = parseInputAlphabet(input);
@@ -245,13 +245,13 @@ SinglePopDPDA AutomatonFromXMLParser::parseSinglePopDPDA(std::list<sax::Token>&
parseTransitions<SinglePopDPDA>(input, automaton);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "SinglePopDPDA");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::AUTOMATON_SINGLE_POP_DPDA);
return automaton;
}
InputDrivenNPDA AutomatonFromXMLParser::parseInputDrivenNPDA(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "InputDrivenNPDA");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_INPUT_DRIVEN_NPDA);
std::set<State> states = parseStates(input);
std::set<alphabet::Symbol> inputSymbols = parseInputAlphabet(input);
@@ -270,13 +270,13 @@ InputDrivenNPDA AutomatonFromXMLParser::parseInputDrivenNPDA(std::list<sax::Toke
parseInputToPushdownStoreOperation(input, automaton);
parseTransitions<InputDrivenNPDA>(input, automaton);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "InputDrivenNPDA");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::AUTOMATON_INPUT_DRIVEN_NPDA);
return automaton;
}
VisiblyPushdownDPDA AutomatonFromXMLParser::parseVisiblyPushdownDPDA(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "VisiblyPushdownDPDA");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_VISIBLY_PUSHDOWN_DPDA);
std::set<State> states = parseStates(input);
std::set<alphabet::Symbol> callInputSymbols = parseCallInputAlphabet(input);
@@ -297,13 +297,13 @@ VisiblyPushdownDPDA AutomatonFromXMLParser::parseVisiblyPushdownDPDA(std::list<s
parseTransitions<VisiblyPushdownDPDA>(input, automaton);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "VisiblyPushdownDPDA");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::AUTOMATON_VISIBLY_PUSHDOWN_DPDA);
return automaton;
}
VisiblyPushdownNPDA AutomatonFromXMLParser::parseVisiblyPushdownNPDA(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "VisiblyPushdownNPDA");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_VISIBLY_PUSHDOWN_NPDA);
std::set<State> states = parseStates(input);
std::set<alphabet::Symbol> callInputSymbols = parseCallInputAlphabet(input);
@@ -325,13 +325,13 @@ VisiblyPushdownNPDA AutomatonFromXMLParser::parseVisiblyPushdownNPDA(std::list<s
parseTransitions<VisiblyPushdownNPDA>(input, automaton);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "VisiblyPushdownNPDA");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::AUTOMATON_VISIBLY_PUSHDOWN_NPDA);
return automaton;
}
RealTimeHeightDeterministicDPDA AutomatonFromXMLParser::parseRealTimeHeightDeterministicDPDA(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "RealTimeHeightDeterministicDPDA");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_REAL_TIME_HEIGHT_DETERMINISTIC_DPDA);
std::set<State> states = parseStates(input);
std::set<alphabet::Symbol> inputSymbols = parseInputAlphabet(input);
@@ -348,13 +348,13 @@ RealTimeHeightDeterministicDPDA AutomatonFromXMLParser::parseRealTimeHeightDeter
parseTransitions<RealTimeHeightDeterministicDPDA>(input, automaton);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "RealTimeHeightDeterministicDPDA");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::AUTOMATON_REAL_TIME_HEIGHT_DETERMINISTIC_DPDA);
return automaton;
}
RealTimeHeightDeterministicNPDA AutomatonFromXMLParser::parseRealTimeHeightDeterministicNPDA(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "RealTimeHeightDeterministicNPDA");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_REAL_TIME_HEIGHT_DETERMINISTIC_NPDA);
std::set<State> states = parseStates(input);
std::set<alphabet::Symbol> inputSymbols = parseInputAlphabet(input);
@@ -372,13 +372,13 @@ RealTimeHeightDeterministicNPDA AutomatonFromXMLParser::parseRealTimeHeightDeter
parseTransitions<RealTimeHeightDeterministicNPDA>(input, automaton);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "RealTimeHeightDeterministicNPDA");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::AUTOMATON_REAL_TIME_HEIGHT_DETERMINISTIC_NPDA);
return automaton;
}
NPDA AutomatonFromXMLParser::parseNPDA(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "NPDA");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_NPDA);
std::set<State> states = parseStates(input);
std::set<alphabet::Symbol> inputSymbols = parseInputAlphabet(input);
@@ -397,13 +397,13 @@ NPDA AutomatonFromXMLParser::parseNPDA(std::list<sax::Token>& input) const {
parseTransitions<NPDA>(input, automaton);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "NPDA");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::AUTOMATON_NPDA);
return automaton;
}
SinglePopNPDA AutomatonFromXMLParser::parseSinglePopNPDA(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "SinglePopNPDA");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_SINGLE_POP_NPDA);
std::set<State> states = parseStates(input);
std::set<alphabet::Symbol> inputSymbols = parseInputAlphabet(input);
@@ -422,13 +422,13 @@ SinglePopNPDA AutomatonFromXMLParser::parseSinglePopNPDA(std::list<sax::Token>&
parseTransitions<SinglePopNPDA>(input, automaton);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "SinglePopNPDA");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::AUTOMATON_SINGLE_POP_NPDA);
return automaton;
}
OneTapeDTM AutomatonFromXMLParser::parseOneTapeDTM(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "OneTapeTM");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_ONE_TAPE_DTM);
std::set<State> states = parseStates(input);
std::set<alphabet::Symbol> inputSymbols = parseInputAlphabet(input);
@@ -446,7 +446,7 @@ OneTapeDTM AutomatonFromXMLParser::parseOneTapeDTM(std::list<sax::Token>& input)
parseTransitions<OneTapeDTM>(input, automaton);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "OneTapeTM");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::AUTOMATON_ONE_TAPE_DTM);
return automaton;
}
diff --git a/alib2data/src/automaton/AutomatonFromXMLParser.h b/alib2data/src/automaton/AutomatonFromXMLParser.h
index f639bd1aeb2850336d73b607fff2bfa3d44bcfe8..ca58eb5db5ecf19ab1528a7230c799c48199d277 100644
--- a/alib2data/src/automaton/AutomatonFromXMLParser.h
+++ b/alib2data/src/automaton/AutomatonFromXMLParser.h
@@ -126,7 +126,7 @@ class AutomatonFromXMLParser : public sax::FromXMLParserHelper {
template<typename T> friend class alib::api;
public:
- bool first(std::list<sax::Token>& input) const;
+ bool first(const std::list<sax::Token>& input) const;
};
} /* namespace automaton */
diff --git a/alib2data/src/automaton/AutomatonToXMLComposer.cpp b/alib2data/src/automaton/AutomatonToXMLComposer.cpp
index 13a6342588aaceb6449058db70ce914bc8266ad7..2f96ee71545727f590aec51ae8887b434d2b3f01 100644
--- a/alib2data/src/automaton/AutomatonToXMLComposer.cpp
+++ b/alib2data/src/automaton/AutomatonToXMLComposer.cpp
@@ -592,7 +592,7 @@ std::list<sax::Token> AutomatonToXMLComposer::compose(const AutomatonBase& autom
std::list<sax::Token> AutomatonToXMLComposer::compose(const DFA& automaton) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("DFA", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::AUTOMATON_DFA, sax::Token::TokenType::START_ELEMENT));
composeStates(out, automaton.getStates());
composeInputAlphabet(out, automaton.getInputAlphabet());
@@ -600,13 +600,13 @@ std::list<sax::Token> AutomatonToXMLComposer::compose(const DFA& automaton) cons
composeFinalStates(out, automaton.getFinalStates());
composeTransitions(out, automaton);
- out.push_back(sax::Token("DFA", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::AUTOMATON_DFA, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> AutomatonToXMLComposer::compose(const NFA& automaton) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("NFA", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::AUTOMATON_NFA, sax::Token::TokenType::START_ELEMENT));
composeStates(out, automaton.getStates());
composeInputAlphabet(out, automaton.getInputAlphabet());
@@ -614,13 +614,13 @@ std::list<sax::Token> AutomatonToXMLComposer::compose(const NFA& automaton) cons
composeFinalStates(out, automaton.getFinalStates());
composeTransitions(out, automaton);
- out.push_back(sax::Token("NFA", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::AUTOMATON_NFA, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> AutomatonToXMLComposer::compose(const MultiInitialStateNFA& automaton) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("MultiInitialStateNFA", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::AUTOMATON_MULTI_INITIAL_STATE_NFA, sax::Token::TokenType::START_ELEMENT));
composeStates(out, automaton.getStates());
composeInputAlphabet(out, automaton.getInputAlphabet());
@@ -628,13 +628,13 @@ std::list<sax::Token> AutomatonToXMLComposer::compose(const MultiInitialStateNFA
composeFinalStates(out, automaton.getFinalStates());
composeTransitions(out, automaton);
- out.push_back(sax::Token("MultiInitialStateNFA", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::AUTOMATON_MULTI_INITIAL_STATE_NFA, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> AutomatonToXMLComposer::compose(const EpsilonNFA& automaton) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("EpsilonNFA", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::AUTOMATON_EPSILON_NFA, sax::Token::TokenType::START_ELEMENT));
composeStates(out, automaton.getStates());
composeInputAlphabet(out, automaton.getInputAlphabet());
@@ -642,13 +642,13 @@ std::list<sax::Token> AutomatonToXMLComposer::compose(const EpsilonNFA& automato
composeFinalStates(out, automaton.getFinalStates());
composeTransitions(out, automaton);
- out.push_back(sax::Token("EpsilonNFA", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::AUTOMATON_EPSILON_NFA, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> AutomatonToXMLComposer::compose(const ExtendedNFA& automaton) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("ExtendedNFA", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::AUTOMATON_EXTENDED_NFA, sax::Token::TokenType::START_ELEMENT));
composeStates(out, automaton.getStates());
composeInputAlphabet(out, automaton.getInputAlphabet());
@@ -656,13 +656,13 @@ std::list<sax::Token> AutomatonToXMLComposer::compose(const ExtendedNFA& automat
composeFinalStates(out, automaton.getFinalStates());
composeTransitions(out, automaton);
- out.push_back(sax::Token("ExtendedNFA", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::AUTOMATON_EXTENDED_NFA, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> AutomatonToXMLComposer::compose(const CompactNFA& automaton) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("CompactNFA", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::AUTOMATON_COMPACT_NFA, sax::Token::TokenType::START_ELEMENT));
composeStates(out, automaton.getStates());
composeInputAlphabet(out, automaton.getInputAlphabet());
@@ -670,13 +670,13 @@ std::list<sax::Token> AutomatonToXMLComposer::compose(const CompactNFA& automato
composeFinalStates(out, automaton.getFinalStates());
composeTransitions(out, automaton);
- out.push_back(sax::Token("CompactNFA", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::AUTOMATON_COMPACT_NFA, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> AutomatonToXMLComposer::compose(const DPDA& automaton) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("DPDA", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::AUTOMATON_DPDA, sax::Token::TokenType::START_ELEMENT));
composeStates(out, automaton.getStates());
composeInputAlphabet(out, automaton.getInputAlphabet());
@@ -686,13 +686,13 @@ std::list<sax::Token> AutomatonToXMLComposer::compose(const DPDA& automaton) con
composeFinalStates(out, automaton.getFinalStates());
composeTransitions(out, automaton);
- out.push_back(sax::Token("DPDA", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::AUTOMATON_DPDA, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> AutomatonToXMLComposer::compose(const SinglePopDPDA& automaton) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("SinglePopDPDA", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::AUTOMATON_SINGLE_POP_DPDA, sax::Token::TokenType::START_ELEMENT));
composeStates(out, automaton.getStates());
composeInputAlphabet(out, automaton.getInputAlphabet());
@@ -702,13 +702,13 @@ std::list<sax::Token> AutomatonToXMLComposer::compose(const SinglePopDPDA& autom
composeFinalStates(out, automaton.getFinalStates());
composeTransitions(out, automaton);
- out.push_back(sax::Token("SinglePopDPDA", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::AUTOMATON_SINGLE_POP_DPDA, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> AutomatonToXMLComposer::compose(const InputDrivenNPDA& automaton) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("InputDrivenNPDA", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::AUTOMATON_INPUT_DRIVEN_NPDA, sax::Token::TokenType::START_ELEMENT));
composeStates(out, automaton.getStates());
composeInputAlphabet(out, automaton.getInputAlphabet());
@@ -719,13 +719,13 @@ std::list<sax::Token> AutomatonToXMLComposer::compose(const InputDrivenNPDA& aut
composeInputToPushdownStoreOperation(out, automaton);
composeTransitions(out, automaton);
- out.push_back(sax::Token("InputDrivenNPDA", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::AUTOMATON_INPUT_DRIVEN_NPDA, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> AutomatonToXMLComposer::compose(const VisiblyPushdownDPDA& automaton) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("VisiblyPushdownDPDA", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::AUTOMATON_VISIBLY_PUSHDOWN_DPDA, sax::Token::TokenType::START_ELEMENT));
composeStates(out, automaton.getStates());
composeCallInputAlphabet(out, automaton.getCallInputAlphabet());
@@ -737,13 +737,13 @@ std::list<sax::Token> AutomatonToXMLComposer::compose(const VisiblyPushdownDPDA&
composeFinalStates(out, automaton.getFinalStates());
composeTransitions(out, automaton);
- out.push_back(sax::Token("VisiblyPushdownDPDA", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::AUTOMATON_VISIBLY_PUSHDOWN_DPDA, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> AutomatonToXMLComposer::compose(const VisiblyPushdownNPDA& automaton) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("VisiblyPushdownNPDA", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::AUTOMATON_VISIBLY_PUSHDOWN_NPDA, sax::Token::TokenType::START_ELEMENT));
composeStates(out, automaton.getStates());
composeCallInputAlphabet(out, automaton.getCallInputAlphabet());
@@ -755,13 +755,13 @@ std::list<sax::Token> AutomatonToXMLComposer::compose(const VisiblyPushdownNPDA&
composeFinalStates(out, automaton.getFinalStates());
composeTransitions(out, automaton);
- out.push_back(sax::Token("VisiblyPushdownNPDA", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::AUTOMATON_VISIBLY_PUSHDOWN_NPDA, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> AutomatonToXMLComposer::compose(const RealTimeHeightDeterministicDPDA& automaton) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("RealTimeHeightDeterministicDPDA", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::AUTOMATON_REAL_TIME_HEIGHT_DETERMINISTIC_DPDA, sax::Token::TokenType::START_ELEMENT));
composeStates(out, automaton.getStates());
composeInputAlphabet(out, automaton.getInputAlphabet());
@@ -771,13 +771,13 @@ std::list<sax::Token> AutomatonToXMLComposer::compose(const RealTimeHeightDeterm
composeFinalStates(out, automaton.getFinalStates());
composeTransitions(out, automaton);
- out.push_back(sax::Token("RealTimeHeightDeterministicDPDA", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::AUTOMATON_REAL_TIME_HEIGHT_DETERMINISTIC_DPDA, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> AutomatonToXMLComposer::compose(const RealTimeHeightDeterministicNPDA& automaton) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("RealTimeHeightDeterministicNPDA", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::AUTOMATON_REAL_TIME_HEIGHT_DETERMINISTIC_NPDA, sax::Token::TokenType::START_ELEMENT));
composeStates(out, automaton.getStates());
composeInputAlphabet(out, automaton.getInputAlphabet());
@@ -787,13 +787,13 @@ std::list<sax::Token> AutomatonToXMLComposer::compose(const RealTimeHeightDeterm
composeFinalStates(out, automaton.getFinalStates());
composeTransitions(out, automaton);
- out.push_back(sax::Token("RealTimeHeightDeterministicNPDA", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::AUTOMATON_REAL_TIME_HEIGHT_DETERMINISTIC_NPDA, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> AutomatonToXMLComposer::compose(const NPDA& automaton) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("NPDA", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::AUTOMATON_NPDA, sax::Token::TokenType::START_ELEMENT));
composeStates(out, automaton.getStates());
composeInputAlphabet(out, automaton.getInputAlphabet());
@@ -803,13 +803,13 @@ std::list<sax::Token> AutomatonToXMLComposer::compose(const NPDA& automaton) con
composeFinalStates(out, automaton.getFinalStates());
composeTransitions(out, automaton);
- out.push_back(sax::Token("NPDA", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::AUTOMATON_NPDA, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> AutomatonToXMLComposer::compose(const SinglePopNPDA& automaton) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("SinglePopNPDA", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::AUTOMATON_SINGLE_POP_NPDA, sax::Token::TokenType::START_ELEMENT));
composeStates(out, automaton.getStates());
composeInputAlphabet(out, automaton.getInputAlphabet());
@@ -819,13 +819,13 @@ std::list<sax::Token> AutomatonToXMLComposer::compose(const SinglePopNPDA& autom
composeFinalStates(out, automaton.getFinalStates());
composeTransitions(out, automaton);
- out.push_back(sax::Token("SinglePopNPDA", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::AUTOMATON_SINGLE_POP_NPDA, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> AutomatonToXMLComposer::compose(const OneTapeDTM& automaton) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("OneTapeDTM", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::AUTOMATON_ONE_TAPE_DTM, sax::Token::TokenType::START_ELEMENT));
composeStates(out, automaton.getStates());
composeInputAlphabet(out, automaton.getInputAlphabet());
@@ -835,7 +835,7 @@ std::list<sax::Token> AutomatonToXMLComposer::compose(const OneTapeDTM& automato
composeFinalStates(out, automaton.getFinalStates());
composeTransitions(out, automaton);
- out.push_back(sax::Token("OneTapeDTM", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::AUTOMATON_ONE_TAPE_DTM, sax::Token::TokenType::END_ELEMENT));
return out;
}
diff --git a/alib2data/src/container/ContainerFromXMLParser.cpp b/alib2data/src/container/ContainerFromXMLParser.cpp
index 29ff8913abd6f78d96f06ec4be086a06ccbb39fe..540532b4307fe093f3d0c4f828fa4513e4a9383e 100644
--- a/alib2data/src/container/ContainerFromXMLParser.cpp
+++ b/alib2data/src/container/ContainerFromXMLParser.cpp
@@ -10,29 +10,21 @@
namespace container {
-bool ContainerFromXMLParser::first(std::list<sax::Token>& input) const {
- if(isToken(input, sax::Token::TokenType::START_ELEMENT, "set") || isToken(input, sax::Token::TokenType::START_ELEMENT, "vector") || isToken(input, sax::Token::TokenType::START_ELEMENT, "pair") || isToken(input, sax::Token::TokenType::START_ELEMENT, "map")) {
- return true;
- } else {
- return false;
- }
-}
-
Container ContainerFromXMLParser::parseContainer(std::list<sax::Token>& input) const {
return parseContainer(input, std::set<FEATURES>({FEATURES::SET, FEATURES::VECTOR, FEATURES::PAIR, FEATURES::MAP}));
}
Container ContainerFromXMLParser::parseContainer(std::list<sax::Token>& input, const std::set<FEATURES>& features) const {
- if(isToken(input, sax::Token::TokenType::START_ELEMENT, "set")) {
+ if(alib::api<ObjectsSet>::first(input)) {
if(!features.count(FEATURES::SET)) throw exception::AlibException();
return Container(parseObjectsSet(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "vector")) {
+ } else if(alib::api<ObjectsVector>::first(input)) {
if(!features.count(FEATURES::VECTOR)) throw exception::AlibException();
return Container(parseObjectsVector(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "pair")) {
+ } else if(alib::api<ObjectsPair>::first(input)) {
if(!features.count(FEATURES::PAIR)) throw exception::AlibException();
return Container(parseObjectsPair(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "map")) {
+ } else if(alib::api<ObjectsMap>::first(input)) {
if(!features.count(FEATURES::MAP)) throw exception::AlibException();
return Container(parseObjectsMap(input));
} else {
@@ -40,8 +32,16 @@ Container ContainerFromXMLParser::parseContainer(std::list<sax::Token>& input, c
}
}
+bool ContainerFromXMLParser::first(const std::list<sax::Token>& input) const {
+ if(alib::api<ObjectsSet>::first(input) || alib::api<ObjectsVector>::first(input) || alib::api<ObjectsPair>::first(input) || alib::api<ObjectsMap>::first(input)) {
+ return true;
+ } else {
+ return false;
+ }
+}
+
ObjectsSet ContainerFromXMLParser::parseObjectsSet(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "set");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::CONTAINER_OBJECTS_SET);
ObjectsSet set;
@@ -49,12 +49,12 @@ ObjectsSet ContainerFromXMLParser::parseObjectsSet(std::list<sax::Token>& input)
set.insert(alib::api<alib::Object>::parse(input));
}
- popToken(input, sax::Token::TokenType::END_ELEMENT, "set");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::CONTAINER_OBJECTS_SET);
return set;
}
ObjectsVector ContainerFromXMLParser::parseObjectsVector(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "vector");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::CONTAINER_OBJECTS_VECTOR);
ObjectsVector vector;
@@ -62,31 +62,31 @@ ObjectsVector ContainerFromXMLParser::parseObjectsVector(std::list<sax::Token>&
vector.push_back(alib::api<alib::Object>::parse(input));
}
- popToken(input, sax::Token::TokenType::END_ELEMENT, "vector");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::CONTAINER_OBJECTS_VECTOR);
return vector;
}
ObjectsPair ContainerFromXMLParser::parseObjectsPair(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "pair");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::CONTAINER_OBJECTS_PAIR);
alib::Object first = alib::api<alib::Object>::parse(input);
alib::Object second = alib::api<alib::Object>::parse(input);
ObjectsPair pair(first, second);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "pair");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::CONTAINER_OBJECTS_PAIR);
return pair;
}
ObjectsMap ContainerFromXMLParser::parseObjectsMap(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "map");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::CONTAINER_OBJECTS_MAP);
ObjectsMap map;
while(isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
map.insert(alib::api<std::pair<alib::Object, alib::Object>>::parse(input));
}
- popToken(input, sax::Token::TokenType::END_ELEMENT, "map");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::CONTAINER_OBJECTS_MAP);
return map;
}
diff --git a/alib2data/src/container/ContainerFromXMLParser.hpp b/alib2data/src/container/ContainerFromXMLParser.hpp
index ab4d4248cbccc63ae926513c57599cbf665769e1..d59a7146b3c08b1e3193a5e8e69a809d39809d61 100644
--- a/alib2data/src/container/ContainerFromXMLParser.hpp
+++ b/alib2data/src/container/ContainerFromXMLParser.hpp
@@ -57,7 +57,7 @@ class ContainerFromXMLParser : public sax::FromXMLParserHelper {
template<typename T> friend class alib::api;
public:
- bool first(std::list<sax::Token>& input) const;
+ bool first(const std::list<sax::Token>& input) const;
};
} /* namespace container */
@@ -68,7 +68,7 @@ namespace container {
template<typename T>
std::set<T> ContainerFromXMLParser::parseSet(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "set");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::CONTAINER_OBJECTS_SET);
std::set<T> set;
@@ -76,13 +76,13 @@ std::set<T> ContainerFromXMLParser::parseSet(std::list<sax::Token>& input) const
set.insert(alib::api<T>::parse(input));
}
- popToken(input, sax::Token::TokenType::END_ELEMENT, "set");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::CONTAINER_OBJECTS_SET);
return set;
}
template<typename T>
std::vector<T> ContainerFromXMLParser::parseVector(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "vector");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::CONTAINER_OBJECTS_VECTOR);
std::vector<T> vector;
@@ -90,24 +90,24 @@ std::vector<T> ContainerFromXMLParser::parseVector(std::list<sax::Token>& input)
vector.push_back(alib::api<T>::parse(input));
}
- popToken(input, sax::Token::TokenType::END_ELEMENT, "vector");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::CONTAINER_OBJECTS_VECTOR);
return vector;
}
template<typename T, typename R>
std::pair<T, R> ContainerFromXMLParser::parsePair(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "pair");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::CONTAINER_OBJECTS_PAIR);
T first = alib::api<T>::parse(input);
R second = alib::api<R>::parse(input);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "pair");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::CONTAINER_OBJECTS_PAIR);
return std::make_pair(first, second);
}
template<typename T, typename R>
std::map<T, R> ContainerFromXMLParser::parseMap(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "map");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::CONTAINER_OBJECTS_MAP);
std::map<T, R> map;
@@ -115,7 +115,7 @@ std::map<T, R> ContainerFromXMLParser::parseMap(std::list<sax::Token>& input) co
map.insert(alib::api<std::pair<T, R>>::parse(input));
}
- popToken(input, sax::Token::TokenType::END_ELEMENT, "map");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::CONTAINER_OBJECTS_MAP);
return map;
}
diff --git a/alib2data/src/container/ContainerToXMLComposer.cpp b/alib2data/src/container/ContainerToXMLComposer.cpp
index ecfad0e3c7948f59c69e019b3d0c6fcce82768a7..e6a5cee3181774768f7cd2f6ee021ff564c51410 100644
--- a/alib2data/src/container/ContainerToXMLComposer.cpp
+++ b/alib2data/src/container/ContainerToXMLComposer.cpp
@@ -23,48 +23,48 @@ std::list<sax::Token> ContainerToXMLComposer::compose(const Container& container
std::list<sax::Token> ContainerToXMLComposer::compose(const ObjectsSet& container) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("set", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_SET, sax::Token::TokenType::START_ELEMENT));
for(const alib::Object& item : container) {
out.splice(out.end(), alib::api<alib::Object>::compose(item));
}
- out.push_back(sax::Token("set", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_SET, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> ContainerToXMLComposer::compose(const ObjectsVector& container) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("vector", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_VECTOR, sax::Token::TokenType::START_ELEMENT));
for(const alib::Object& item : container) {
out.splice(out.end(), alib::api<alib::Object>::compose(item));
}
- out.push_back(sax::Token("vector", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_VECTOR, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> ContainerToXMLComposer::compose(const ObjectsPair& container) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("pair", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_PAIR, sax::Token::TokenType::START_ELEMENT));
out.splice(out.end(), alib::api<alib::Object>::compose(container.first));
out.splice(out.end(), alib::api<alib::Object>::compose(container.second));
- out.push_back(sax::Token("pair", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_PAIR, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> ContainerToXMLComposer::compose(const ObjectsMap& container) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("map", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_MAP, sax::Token::TokenType::START_ELEMENT));
for(const std::pair<alib::Object, alib::Object>& item : container) {
out.splice(out.end(), alib::api<std::pair<alib::Object, alib::Object>>::compose(item));
}
- out.push_back(sax::Token("map", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_MAP, sax::Token::TokenType::END_ELEMENT));
return out;
}
diff --git a/alib2data/src/container/ContainerToXMLComposer.hpp b/alib2data/src/container/ContainerToXMLComposer.hpp
index 7e6f4fa0c379b9f0ca33495f79f7781684937a4e..34de226b2bf6b7eb258daac3feac9b0740bd2994 100644
--- a/alib2data/src/container/ContainerToXMLComposer.hpp
+++ b/alib2data/src/container/ContainerToXMLComposer.hpp
@@ -75,51 +75,51 @@ namespace container {
template<typename T>
std::list<sax::Token> ContainerToXMLComposer::compose(const std::set<T>& container) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("set", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_SET, sax::Token::TokenType::START_ELEMENT));
for(const T& item : container) {
out.splice(out.end(), alib::api<T>::compose(item));
}
- out.push_back(sax::Token("set", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_SET, sax::Token::TokenType::END_ELEMENT));
return out;
}
template<typename T>
std::list<sax::Token> ContainerToXMLComposer::compose(const std::vector<T>& container) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("vector", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_VECTOR, sax::Token::TokenType::START_ELEMENT));
for(const T& item : container) {
out.splice(out.end(), alib::api<T>::compose(item));
}
- out.push_back(sax::Token("vector", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_VECTOR, sax::Token::TokenType::END_ELEMENT));
return out;
}
template<typename T, typename R>
std::list<sax::Token> ContainerToXMLComposer::compose(const std::pair<T, R>& container) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("pair", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_PAIR, sax::Token::TokenType::START_ELEMENT));
out.splice(out.end(), alib::api<T>::compose(container.first));
out.splice(out.end(), alib::api<R>::compose(container.second));
- out.push_back(sax::Token("pair", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_PAIR, sax::Token::TokenType::END_ELEMENT));
return out;
}
template<typename T, typename R>
std::list<sax::Token> ContainerToXMLComposer::compose(const std::map<T, R>& container) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("map", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_MAP, sax::Token::TokenType::START_ELEMENT));
for(const std::pair<T, R>& item : container) {
out.splice(out.end(), alib::api<std::pair<T, R>>::compose(item));
}
- out.push_back(sax::Token("map", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_MAP, sax::Token::TokenType::END_ELEMENT));
return out;
}
diff --git a/alib2data/src/exception/AlibException.cpp b/alib2data/src/exception/AlibException.cpp
index ab7e44fc1815c7b1490bd18b78c8463375c82538..8571d7527d2749e35580d69f5272c6c0f7084bb9 100644
--- a/alib2data/src/exception/AlibException.cpp
+++ b/alib2data/src/exception/AlibException.cpp
@@ -35,6 +35,14 @@ AlibException::AlibException ( const std::string & cause ) : AlibException { } {
this->whatMessage += this->cause;
}
+AlibException::AlibException ( const std::string & cause, const std::string& backtrace ) : AlibException { } {
+ this->backtrace = backtrace;
+ this->cause = cause;
+
+ this->whatMessage += this->backtrace;
+ this->whatMessage += this->cause;
+}
+
AlibException::~AlibException ( ) noexcept {
}
diff --git a/alib2data/src/exception/AlibException.h b/alib2data/src/exception/AlibException.h
index bcdb502fd85b1aed7467d8c7c946d81efadf869a..09f53c66c1c6c84bd21a3a4b40f9865577649362 100644
--- a/alib2data/src/exception/AlibException.h
+++ b/alib2data/src/exception/AlibException.h
@@ -30,6 +30,8 @@ public:
explicit AlibException ( const std::string & cause );
+ explicit AlibException ( const std::string & cause, const std::string& backtrace );
+
virtual ~AlibException ( ) noexcept;
virtual alib::ObjectBase* clone() const;
diff --git a/alib2data/src/exception/ExceptionFromXMLParser.cpp b/alib2data/src/exception/ExceptionFromXMLParser.cpp
index 29298941ae526ac931c6c9e55f209b11d05b52c8..6ee369c7ceefb0ff3dd5da3218299093f81e5f21 100644
--- a/alib2data/src/exception/ExceptionFromXMLParser.cpp
+++ b/alib2data/src/exception/ExceptionFromXMLParser.cpp
@@ -9,6 +9,8 @@
#include "../sax/ParserException.h"
#include <string>
+#include "../Api.hpp"
+
namespace exception {
AlibException ExceptionFromXMLParser::parseException(std::list<sax::Token>& input) const {
@@ -17,18 +19,27 @@ AlibException ExceptionFromXMLParser::parseException(std::list<sax::Token>& inpu
AlibException ExceptionFromXMLParser::parseException(std::list<sax::Token>& input, const std::set<FEATURES>& features) const {
if(!features.count(FEATURES::ALIB_EXCEPTION)) throw exception::AlibException();
- popToken(input, sax::Token::TokenType::START_ELEMENT, "exception");
+ 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();
}
- popToken(input, sax::Token::TokenType::END_ELEMENT, "exception");
- return AlibException(cause);
+ 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();
+ }
+ popToken(input, sax::Token::TokenType::END_ELEMENT, "backtrace");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::EXCEPTION_ALIB_EXCEPTION);
+ return AlibException(cause, backtrace);
}
-bool ExceptionFromXMLParser::first(std::list<sax::Token>& input) const {
- if(isToken(input, sax::Token::TokenType::START_ELEMENT, "exception")) {
+bool ExceptionFromXMLParser::first(const std::list<sax::Token>& input) const {
+ if(alib::api<AlibException>::first(input)) {
return true;
} else {
return false;
diff --git a/alib2data/src/exception/ExceptionFromXMLParser.h b/alib2data/src/exception/ExceptionFromXMLParser.h
index ee94c2a235e45ce5c34e5798b522f375a1d924d2..10dacf6c222dcbf4b460fcf52bca96a6ec7e76a8 100644
--- a/alib2data/src/exception/ExceptionFromXMLParser.h
+++ b/alib2data/src/exception/ExceptionFromXMLParser.h
@@ -31,7 +31,7 @@ class ExceptionFromXMLParser : public sax::FromXMLParserHelper {
AlibException parseException(std::list<sax::Token>& input, const std::set<FEATURES>& features) const;
public:
- bool first(std::list<sax::Token>& input) const;
+ bool first(const std::list<sax::Token>& input) const;
template<typename T> friend class alib::api;
};
diff --git a/alib2data/src/exception/ExceptionToXMLComposer.cpp b/alib2data/src/exception/ExceptionToXMLComposer.cpp
index 5ba436e8c25633b6d7de9fc2d40c4e9c02e05d79..f7fa2946521b4ecf8af7aa63947917be8d7d7da8 100644
--- a/alib2data/src/exception/ExceptionToXMLComposer.cpp
+++ b/alib2data/src/exception/ExceptionToXMLComposer.cpp
@@ -7,14 +7,21 @@
#include "ExceptionToXMLComposer.h"
+#include "../Api.hpp"
+
namespace exception {
std::list<sax::Token> ExceptionToXMLComposer::compose(const AlibException& exception) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("exception", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::EXCEPTION_ALIB_EXCEPTION, sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token("cause", sax::Token::TokenType::START_ELEMENT));
out.push_back(sax::Token(exception.getCause(), sax::Token::TokenType::CHARACTER));
- out.push_back(sax::Token("exception", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token("cause", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token("backtrace", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(exception.getBacktrace(), sax::Token::TokenType::CHARACTER));
+ out.push_back(sax::Token("backtrace", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::EXCEPTION_ALIB_EXCEPTION, sax::Token::TokenType::END_ELEMENT));
return out;
}
diff --git a/alib2data/src/grammar/GrammarFromXMLParser.cpp b/alib2data/src/grammar/GrammarFromXMLParser.cpp
index 7823887f6d7623ea38877e19739eb35fa01bc9ba..06441c01ef330dcae0ac17cfae2157167f0491a9 100644
--- a/alib2data/src/grammar/GrammarFromXMLParser.cpp
+++ b/alib2data/src/grammar/GrammarFromXMLParser.cpp
@@ -19,51 +19,51 @@ Grammar GrammarFromXMLParser::parseGrammar(std::list<sax::Token> &input) const {
}
Grammar GrammarFromXMLParser::parseGrammar(std::list<sax::Token>& input, const std::set<FEATURES>& features) const {
- if(isToken(input, sax::Token::TokenType::START_ELEMENT, "UnrestrictedGrammar")) {
+ if(alib::api<UnrestrictedGrammar>::first(input)) {
if(!features.count(FEATURES::UNRESTRICTED_GRAMMAR)) throw exception::AlibException();
return Grammar(parseUnrestrictedGrammar(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "ContextPreservingUnrestrictedGrammar")) {
+ } else if(alib::api<ContextPreservingUnrestrictedGrammar>::first(input)) {
if(!features.count(FEATURES::CONTEXT_PRESERVING_UNRESTRICTED_GRAMMAR)) throw exception::AlibException();
return Grammar(parseContextPreservingUnrestrictedGrammar(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "NonContractingGrammar")) {
+ } else if(alib::api<NonContractingGrammar>::first(input)) {
if(!features.count(FEATURES::NON_CONTRACTING_GRAMMAR)) throw exception::AlibException();
return Grammar(parseNonContractingGrammar(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "CSG")) {
+ } else if(alib::api<CSG>::first(input)) {
if(!features.count(FEATURES::CSG)) throw exception::AlibException();
return Grammar(parseCSG(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "GNF")) {
+ } else if(alib::api<GNF>::first(input)) {
if(!features.count(FEATURES::GNF)) throw exception::AlibException();
return Grammar(parseGNF(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "CNF")) {
+ } else if(alib::api<CNF>::first(input)) {
if(!features.count(FEATURES::CNF)) throw exception::AlibException();
return Grammar(parseCNF(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "EpsilonFreeCFG")) {
+ } else if(alib::api<EpsilonFreeCFG>::first(input)) {
if(!features.count(FEATURES::EPSILON_FREE_CFG)) throw exception::AlibException();
return Grammar(parseEpsilonFreeCFG(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "CFG")) {
+ } else if(alib::api<CFG>::first(input)) {
if(!features.count(FEATURES::CFG)) throw exception::AlibException();
return Grammar(parseCFG(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "LG")) {
+ } else if(alib::api<LG>::first(input)) {
if(!features.count(FEATURES::LG)) throw exception::AlibException();
return Grammar(parseLG(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "RightRG")) {
+ } else if(alib::api<RightRG>::first(input)) {
if(!features.count(FEATURES::RIGHT_RG)) throw exception::AlibException();
return Grammar(parseRightRG(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "RightLG")) {
+ } else if(alib::api<RightLG>::first(input)) {
if(!features.count(FEATURES::RIGHT_LG)) throw exception::AlibException();
return Grammar(parseRightLG(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "LeftRG")) {
+ } else if(alib::api<LeftRG>::first(input)) {
if(!features.count(FEATURES::LEFT_RG)) throw exception::AlibException();
return Grammar(parseLeftRG(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "LeftLG")) {
+ } else if(alib::api<LeftLG>::first(input)) {
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());
}
-bool GrammarFromXMLParser::first(std::list<sax::Token>& input) const {
- if(isToken(input, sax::Token::TokenType::START_ELEMENT, "grammar") || isToken(input, sax::Token::TokenType::START_ELEMENT, "UnrestrictedGrammar") || isToken(input, sax::Token::TokenType::START_ELEMENT, "ContextPreservingUnrestrictedGrammar") || isToken(input, sax::Token::TokenType::START_ELEMENT, "NonContractingGrammar") || isToken(input, sax::Token::TokenType::START_ELEMENT, "CSG") || isToken(input, sax::Token::TokenType::START_ELEMENT, "GNF") || isToken(input, sax::Token::TokenType::START_ELEMENT, "CNF") || isToken(input, sax::Token::TokenType::START_ELEMENT, "EpsilonFreeCFG") || isToken(input, sax::Token::TokenType::START_ELEMENT, "CFG") || isToken(input, sax::Token::TokenType::START_ELEMENT, "LG") || isToken(input, sax::Token::TokenType::START_ELEMENT, "RightRG") || isToken(input, sax::Token::TokenType::START_ELEMENT, "RightLG") || isToken(input, sax::Token::TokenType::START_ELEMENT, "LeftLG") || isToken(input, sax::Token::TokenType::START_ELEMENT, "LeftLG")) {
+bool GrammarFromXMLParser::first(const std::list<sax::Token>& input) const {
+ if(alib::api<UnrestrictedGrammar>::first(input) || alib::api<ContextPreservingUnrestrictedGrammar>::first(input) || alib::api<NonContractingGrammar>::first(input) || alib::api<CSG>::first(input) || alib::api<GNF>::first(input) || alib::api<CNF>::first(input) || alib::api<EpsilonFreeCFG>::first(input) || alib::api<CFG>::first(input) || alib::api<LG>::first(input) || alib::api<RightRG>::first(input) || alib::api<RightLG>::first(input) || alib::api<LeftLG>::first(input) || alib::api<LeftLG>::first(input)) {
return true;
} else {
return false;
@@ -71,7 +71,7 @@ bool GrammarFromXMLParser::first(std::list<sax::Token>& input) const {
}
UnrestrictedGrammar GrammarFromXMLParser::parseUnrestrictedGrammar(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "UnrestrictedGrammar");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_UNRESTRICTED_GRAMMAR);
std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
@@ -83,12 +83,12 @@ UnrestrictedGrammar GrammarFromXMLParser::parseUnrestrictedGrammar(std::list<sax
parseRules(input, grammar);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "UnrestrictedGrammar");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::GRAMMAR_UNRESTRICTED_GRAMMAR);
return grammar;
}
ContextPreservingUnrestrictedGrammar GrammarFromXMLParser::parseContextPreservingUnrestrictedGrammar(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "ContextPreservingUnrestrictedGrammar");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_CONTEXT_PRESERVING_UNRESTRICTED_GRAMMAR);
std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
@@ -100,12 +100,12 @@ ContextPreservingUnrestrictedGrammar GrammarFromXMLParser::parseContextPreservin
parseRules(input, grammar);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "ContextPreservingUnrestrictedGrammar");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::GRAMMAR_CONTEXT_PRESERVING_UNRESTRICTED_GRAMMAR);
return grammar;
}
NonContractingGrammar GrammarFromXMLParser::parseNonContractingGrammar(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "NonContractingGrammar");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_NON_CONTRACTING_GRAMMAR);
std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
@@ -120,12 +120,12 @@ NonContractingGrammar GrammarFromXMLParser::parseNonContractingGrammar(std::list
bool generatesEpsilon = parseGeneratesEpsilon(input);
grammar.setGeneratesEpsilon(generatesEpsilon);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "NonContractingGrammar");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::GRAMMAR_NON_CONTRACTING_GRAMMAR);
return grammar;
}
CSG GrammarFromXMLParser::parseCSG(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "CSG");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_CSG);
std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
@@ -140,12 +140,12 @@ CSG GrammarFromXMLParser::parseCSG(std::list<sax::Token>& input) const {
bool generatesEpsilon = parseGeneratesEpsilon(input);
grammar.setGeneratesEpsilon(generatesEpsilon);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "CSG");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::GRAMMAR_CSG);
return grammar;
}
GNF GrammarFromXMLParser::parseGNF(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "GNF");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_GNF);
std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
@@ -160,12 +160,12 @@ GNF GrammarFromXMLParser::parseGNF(std::list<sax::Token>& input) const {
bool generatesEpsilon = parseGeneratesEpsilon(input);
grammar.setGeneratesEpsilon(generatesEpsilon);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "GNF");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::GRAMMAR_GNF);
return grammar;
}
CNF GrammarFromXMLParser::parseCNF(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "CNF");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_CNF);
std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
@@ -180,12 +180,12 @@ CNF GrammarFromXMLParser::parseCNF(std::list<sax::Token>& input) const {
bool generatesEpsilon = parseGeneratesEpsilon(input);
grammar.setGeneratesEpsilon(generatesEpsilon);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "CNF");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::GRAMMAR_CNF);
return grammar;
}
EpsilonFreeCFG GrammarFromXMLParser::parseEpsilonFreeCFG(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "EpsilonFreeCFG");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_EPSILON_FREE_CFG);
std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
@@ -200,12 +200,12 @@ EpsilonFreeCFG GrammarFromXMLParser::parseEpsilonFreeCFG(std::list<sax::Token>&
bool generatesEpsilon = parseGeneratesEpsilon(input);
grammar.setGeneratesEpsilon(generatesEpsilon);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "EpsilonFreeCFG");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::GRAMMAR_EPSILON_FREE_CFG);
return grammar;
}
CFG GrammarFromXMLParser::parseCFG(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "CFG");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_CFG);
std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
@@ -217,12 +217,12 @@ CFG GrammarFromXMLParser::parseCFG(std::list<sax::Token>& input) const {
parseRules(input, grammar);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "CFG");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::GRAMMAR_CFG);
return grammar;
}
LG GrammarFromXMLParser::parseLG(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "LG");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_LG);
std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
@@ -234,12 +234,12 @@ LG GrammarFromXMLParser::parseLG(std::list<sax::Token>& input) const {
parseRules(input, grammar);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "LG");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::GRAMMAR_LG);
return grammar;
}
RightRG GrammarFromXMLParser::parseRightRG(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "RightRG");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_RIGHT_RG);
std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
@@ -254,12 +254,12 @@ RightRG GrammarFromXMLParser::parseRightRG(std::list<sax::Token>& input) const {
bool generatesEpsilon = parseGeneratesEpsilon(input);
grammar.setGeneratesEpsilon(generatesEpsilon);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "RightRG");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::GRAMMAR_RIGHT_RG);
return grammar;
}
RightLG GrammarFromXMLParser::parseRightLG(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "RightLG");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_RIGHT_LG);
std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
@@ -271,12 +271,12 @@ RightLG GrammarFromXMLParser::parseRightLG(std::list<sax::Token>& input) const {
parseRules(input, grammar);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "RightLG");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::GRAMMAR_RIGHT_LG);
return grammar;
}
LeftRG GrammarFromXMLParser::parseLeftRG(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "LeftRG");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_LEFT_RG);
std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
@@ -291,12 +291,12 @@ LeftRG GrammarFromXMLParser::parseLeftRG(std::list<sax::Token>& input) const {
bool generatesEpsilon = parseGeneratesEpsilon(input);
grammar.setGeneratesEpsilon(generatesEpsilon);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "LeftRG");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::GRAMMAR_LEFT_RG);
return grammar;
}
LeftLG GrammarFromXMLParser::parseLeftLG(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "LeftLG");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_LEFT_LG);
std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
@@ -308,7 +308,7 @@ LeftLG GrammarFromXMLParser::parseLeftLG(std::list<sax::Token>& input) const {
parseRules(input, grammar);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "LeftLG");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::GRAMMAR_LEFT_LG);
return grammar;
}
diff --git a/alib2data/src/grammar/GrammarFromXMLParser.h b/alib2data/src/grammar/GrammarFromXMLParser.h
index d667bc1eb52678814496995b336d2870c6ce31c8..13fb785df0adc3da0c4631170ea1c451aa793bc3 100644
--- a/alib2data/src/grammar/GrammarFromXMLParser.h
+++ b/alib2data/src/grammar/GrammarFromXMLParser.h
@@ -92,7 +92,7 @@ class GrammarFromXMLParser : public sax::FromXMLParserHelper {
template<typename T> friend class alib::api;
public:
- bool first(std::list<sax::Token>& input) const;
+ bool first(const std::list<sax::Token>& input) const;
};
} /* namespace grammar */
diff --git a/alib2data/src/grammar/GrammarToXMLComposer.cpp b/alib2data/src/grammar/GrammarToXMLComposer.cpp
index b6eb02409049adc4d5a26ca8cd70bb6cced6c4ce..31c1e6de530c6594287d3c01b4687150bdf1c3cb 100644
--- a/alib2data/src/grammar/GrammarToXMLComposer.cpp
+++ b/alib2data/src/grammar/GrammarToXMLComposer.cpp
@@ -26,20 +26,20 @@ std::list<sax::Token> GrammarToXMLComposer::compose(const Grammar& grammar) cons
std::list<sax::Token> GrammarToXMLComposer::compose(const LeftLG& grammar) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("LeftLG", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::GRAMMAR_LEFT_LG, sax::Token::TokenType::START_ELEMENT));
composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
composeInitialSymbol(out, grammar.getInitialSymbol());
composeRules(out, grammar);
- out.push_back(sax::Token("LeftLG", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::GRAMMAR_LEFT_LG, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> GrammarToXMLComposer::compose(const LeftRG& grammar) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("LeftRG", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::GRAMMAR_LEFT_RG, sax::Token::TokenType::START_ELEMENT));
composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
@@ -47,26 +47,26 @@ std::list<sax::Token> GrammarToXMLComposer::compose(const LeftRG& grammar) const
composeRules(out, grammar);
composeGeneratesEpsilon(out, grammar.getGeneratesEpsilon());
- out.push_back(sax::Token("LeftRG", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::GRAMMAR_LEFT_RG, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> GrammarToXMLComposer::compose(const RightLG& grammar) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("RightLG", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::GRAMMAR_RIGHT_LG, sax::Token::TokenType::START_ELEMENT));
composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
composeInitialSymbol(out, grammar.getInitialSymbol());
composeRules(out, grammar);
- out.push_back(sax::Token("RightLG", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::GRAMMAR_RIGHT_LG, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> GrammarToXMLComposer::compose(const RightRG& grammar) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("RightRG", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::GRAMMAR_RIGHT_RG, sax::Token::TokenType::START_ELEMENT));
composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
@@ -74,39 +74,39 @@ std::list<sax::Token> GrammarToXMLComposer::compose(const RightRG& grammar) cons
composeRules(out, grammar);
composeGeneratesEpsilon(out, grammar.getGeneratesEpsilon());
- out.push_back(sax::Token("RightRG", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::GRAMMAR_RIGHT_RG, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> GrammarToXMLComposer::compose(const LG& grammar) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("LG", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::GRAMMAR_LG, sax::Token::TokenType::START_ELEMENT));
composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
composeInitialSymbol(out, grammar.getInitialSymbol());
composeRules(out, grammar);
- out.push_back(sax::Token("LG", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::GRAMMAR_LG, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> GrammarToXMLComposer::compose(const CFG& grammar) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("CFG", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::GRAMMAR_CFG, sax::Token::TokenType::START_ELEMENT));
composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
composeInitialSymbol(out, grammar.getInitialSymbol());
composeRules(out, grammar);
- out.push_back(sax::Token("CFG", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::GRAMMAR_CFG, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> GrammarToXMLComposer::compose(const EpsilonFreeCFG& grammar) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("EpsilonFreeCFG", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::GRAMMAR_EPSILON_FREE_CFG, sax::Token::TokenType::START_ELEMENT));
composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
@@ -114,13 +114,13 @@ std::list<sax::Token> GrammarToXMLComposer::compose(const EpsilonFreeCFG& gramma
composeRules(out, grammar);
composeGeneratesEpsilon(out, grammar.getGeneratesEpsilon());
- out.push_back(sax::Token("EpsilonFreeCFG", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::GRAMMAR_EPSILON_FREE_CFG, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> GrammarToXMLComposer::compose(const CNF& grammar) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("CNF", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::GRAMMAR_CNF, sax::Token::TokenType::START_ELEMENT));
composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
@@ -128,13 +128,13 @@ std::list<sax::Token> GrammarToXMLComposer::compose(const CNF& grammar) const {
composeRules(out, grammar);
composeGeneratesEpsilon(out, grammar.getGeneratesEpsilon());
- out.push_back(sax::Token("CNF", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::GRAMMAR_CNF, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> GrammarToXMLComposer::compose(const GNF& grammar) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("GNF", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::GRAMMAR_GNF, sax::Token::TokenType::START_ELEMENT));
composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
@@ -142,13 +142,13 @@ std::list<sax::Token> GrammarToXMLComposer::compose(const GNF& grammar) const {
composeRules(out, grammar);
composeGeneratesEpsilon(out, grammar.getGeneratesEpsilon());
- out.push_back(sax::Token("GNF", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::GRAMMAR_GNF, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> GrammarToXMLComposer::compose(const CSG& grammar) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("CSG", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::GRAMMAR_CSG, sax::Token::TokenType::START_ELEMENT));
composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
@@ -156,13 +156,13 @@ std::list<sax::Token> GrammarToXMLComposer::compose(const CSG& grammar) const {
composeRules(out, grammar);
composeGeneratesEpsilon(out, grammar.getGeneratesEpsilon());
- out.push_back(sax::Token("CSG", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::GRAMMAR_CSG, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> GrammarToXMLComposer::compose(const NonContractingGrammar& grammar) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("NonContractingGrammar", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::GRAMMAR_NON_CONTRACTING_GRAMMAR, sax::Token::TokenType::START_ELEMENT));
composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
@@ -170,33 +170,33 @@ std::list<sax::Token> GrammarToXMLComposer::compose(const NonContractingGrammar&
composeRules(out, grammar);
composeGeneratesEpsilon(out, grammar.getGeneratesEpsilon());
- out.push_back(sax::Token("NonContractingGrammar", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::GRAMMAR_NON_CONTRACTING_GRAMMAR, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> GrammarToXMLComposer::compose(const ContextPreservingUnrestrictedGrammar& grammar) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("ContextPreservingUnrestrictedGrammar", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::GRAMMAR_CONTEXT_PRESERVING_UNRESTRICTED_GRAMMAR, sax::Token::TokenType::START_ELEMENT));
composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
composeInitialSymbol(out, grammar.getInitialSymbol());
composeRules(out, grammar);
- out.push_back(sax::Token("ContextPreservingUnrestrictedGrammar", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::GRAMMAR_CONTEXT_PRESERVING_UNRESTRICTED_GRAMMAR, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> GrammarToXMLComposer::compose(const UnrestrictedGrammar& grammar) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("UnrestrictedGrammar", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::GRAMMAR_UNRESTRICTED_GRAMMAR, sax::Token::TokenType::START_ELEMENT));
composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
composeInitialSymbol(out, grammar.getInitialSymbol());
composeRules(out, grammar);
- out.push_back(sax::Token("UnrestrictedGrammar", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::GRAMMAR_UNRESTRICTED_GRAMMAR, sax::Token::TokenType::END_ELEMENT));
return out;
}
diff --git a/alib2data/src/label/LabelFromXMLParser.cpp b/alib2data/src/label/LabelFromXMLParser.cpp
index adcd1a45f5d268f5ec27d5b1369441189e1d1a52..de0fd8dd76cc2c78702709866c512ea30b4841b1 100644
--- a/alib2data/src/label/LabelFromXMLParser.cpp
+++ b/alib2data/src/label/LabelFromXMLParser.cpp
@@ -17,19 +17,19 @@ Label LabelFromXMLParser::parseLabel(std::list<sax::Token>& input) const {
}
Label LabelFromXMLParser::parseLabel(std::list<sax::Token>& input, const std::set<FEATURES>& features) const {
- if(isToken(input, sax::Token::TokenType::START_ELEMENT, "PrimitiveLabel")) {
+ if(alib::api<PrimitiveLabel>::first(input)) {
if(!features.count(FEATURES::PRIMITIVE)) throw exception::AlibException();
return Label(parsePrimitiveLabel(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "HexavigesimalLabel")) {
+ } else if(alib::api<HexavigesimalLabel>::first(input)) {
if(!features.count(FEATURES::HEXAVIGESIMAL)) throw exception::AlibException();
return Label(parseHexavigesimalLabel(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "ObjectLabel")) {
+ } else if(alib::api<ObjectLabel>::first(input)) {
if(!features.count(FEATURES::OBJECT)) throw exception::AlibException();
return Label(parseObjectLabel(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "LabelSetLabel")) {
+ } else if(alib::api<LabelSetLabel>::first(input)) {
if(!features.count(FEATURES::LABEL_SET)) throw exception::AlibException();
return Label(parseLabelSetLabel(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "LabelPairLabel")) {
+ } else if(alib::api<LabelPairLabel>::first(input)) {
if(!features.count(FEATURES::LABEL_PAIR)) throw exception::AlibException();
return Label(parseLabelPairLabel(input));
} else {
@@ -37,8 +37,8 @@ Label LabelFromXMLParser::parseLabel(std::list<sax::Token>& input, const std::se
}
}
-bool LabelFromXMLParser::first(std::list<sax::Token>& input) const {
- if(isToken(input, sax::Token::TokenType::START_ELEMENT, "PrimitiveLabel") || isToken(input, sax::Token::TokenType::START_ELEMENT, "ObjectLabel") || isToken(input, sax::Token::TokenType::START_ELEMENT, "LabelSetLabel") || isToken(input, sax::Token::TokenType::START_ELEMENT, "LabelPairLabel")) {
+bool LabelFromXMLParser::first(const std::list<sax::Token>& input) const {
+ if(alib::api<PrimitiveLabel>::first(input) || alib::api<ObjectLabel>::first(input) || alib::api<LabelSetLabel>::first(input) || alib::api<LabelPairLabel>::first(input)) {
return true;
} else {
return false;
@@ -46,45 +46,45 @@ bool LabelFromXMLParser::first(std::list<sax::Token>& input) const {
}
PrimitiveLabel LabelFromXMLParser::parsePrimitiveLabel(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "PrimitiveLabel");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::LABEL_PRIMITIVE_LABEL);
PrimitiveLabel data(alib::api<primitive::Primitive>::parse(input));
- popToken(input, sax::Token::TokenType::END_ELEMENT, "PrimitiveLabel");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::LABEL_PRIMITIVE_LABEL);
return data;
}
HexavigesimalLabel LabelFromXMLParser::parseHexavigesimalLabel(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "HexavigesimalLabel");
+ 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, "HexavigesimalLabel");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::LABEL_HEXAVIGESIMAL_LABEL);
return data;
}
ObjectLabel LabelFromXMLParser::parseObjectLabel(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "ObjectLabel");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::LABEL_OBJECT_LABEL);
ObjectLabel data(alib::api<alib::Object>::parse(input));
- popToken(input, sax::Token::TokenType::END_ELEMENT, "ObjectLabel");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::LABEL_OBJECT_LABEL);
return data;
}
LabelSetLabel LabelFromXMLParser::parseLabelSetLabel(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "LabelSetLabel");
+ 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)) {
labels.insert(parseLabel(input));
}
LabelSetLabel data(labels);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "LabelSetLabel");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::LABEL_LABEL_SET_LABEL);
return data;
}
LabelPairLabel LabelFromXMLParser::parseLabelPairLabel(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "LabelPairLabel");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::LABEL_LABEL_PAIR_LABEL);
Label firstLabel = parseLabel(input);
Label secondLabel = parseLabel(input);
LabelPairLabel data(std::make_pair(firstLabel, secondLabel));
- popToken(input, sax::Token::TokenType::END_ELEMENT, "LabelPairLabel");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::LABEL_LABEL_PAIR_LABEL);
return data;
}
diff --git a/alib2data/src/label/LabelFromXMLParser.h b/alib2data/src/label/LabelFromXMLParser.h
index 0810178486ceb1126749c45e1111c6454fb47cc2..81cf283787178caccd98e6b261c6c80968c1801d 100644
--- a/alib2data/src/label/LabelFromXMLParser.h
+++ b/alib2data/src/label/LabelFromXMLParser.h
@@ -44,7 +44,7 @@ class LabelFromXMLParser : public sax::FromXMLParserHelper {
template<typename T> friend class alib::api;
public:
- bool first(std::list<sax::Token>& input) const;
+ bool first(const std::list<sax::Token>& input) const;
};
} /* namespace label */
diff --git a/alib2data/src/label/LabelToXMLComposer.cpp b/alib2data/src/label/LabelToXMLComposer.cpp
index de7875afd3885f6dc89bc5b2110a7b2db912f98d..5112366373e8b3c3c6cce54ce77cc8fad2cac537 100644
--- a/alib2data/src/label/LabelToXMLComposer.cpp
+++ b/alib2data/src/label/LabelToXMLComposer.cpp
@@ -26,44 +26,44 @@ std::list<sax::Token> LabelToXMLComposer::compose(const LabelBase& label) const
std::list<sax::Token> LabelToXMLComposer::compose(const PrimitiveLabel& label) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("PrimitiveLabel", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::LABEL_PRIMITIVE_LABEL, sax::Token::TokenType::START_ELEMENT));
out.splice(out.end(), alib::api<primitive::Primitive>::compose(label.getData()));
- out.push_back(sax::Token("PrimitiveLabel", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::LABEL_PRIMITIVE_LABEL, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> LabelToXMLComposer::compose(const HexavigesimalLabel& label) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("HexavigesimalLabel", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::LABEL_HEXAVIGESIMAL_LABEL, sax::Token::TokenType::START_ELEMENT));
out.push_back(sax::Token(std::itos(label.getData()), sax::Token::TokenType::CHARACTER));
- out.push_back(sax::Token("HexavigesimalLabel", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::LABEL_HEXAVIGESIMAL_LABEL, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> LabelToXMLComposer::compose(const ObjectLabel& label) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("ObjectLabel", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::LABEL_OBJECT_LABEL, sax::Token::TokenType::START_ELEMENT));
out.splice(out.end(), alib::api<alib::Object>::compose(label.getData()));
- out.push_back(sax::Token("ObjectLabel", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::LABEL_OBJECT_LABEL, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> LabelToXMLComposer::compose(const LabelSetLabel& label) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("LabelSetLabel", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::LABEL_LABEL_SET_LABEL, sax::Token::TokenType::START_ELEMENT));
for(const Label& innerLabel : label.getData()) {
out.splice(out.end(), alib::api<label::Label>::compose(innerLabel));
}
- out.push_back(sax::Token("LabelSetLabel", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::LABEL_LABEL_SET_LABEL, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> LabelToXMLComposer::compose(const LabelPairLabel& label) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("LabelPairLabel", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::LABEL_LABEL_PAIR_LABEL, sax::Token::TokenType::START_ELEMENT));
out.splice(out.end(), alib::api<label::Label>::compose(label.getData().first));
out.splice(out.end(), alib::api<label::Label>::compose(label.getData().second));
- out.push_back(sax::Token("LabelPairLabel", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::LABEL_LABEL_PAIR_LABEL, sax::Token::TokenType::END_ELEMENT));
return out;
}
diff --git a/alib2data/src/object/ObjectFromXMLParser.cpp b/alib2data/src/object/ObjectFromXMLParser.cpp
index 5d4fc2296fba81f0560c35b5bb15d20d73091113..cde302e07984438c9f121d8cd4d6fbfe35f9d063 100644
--- a/alib2data/src/object/ObjectFromXMLParser.cpp
+++ b/alib2data/src/object/ObjectFromXMLParser.cpp
@@ -51,7 +51,7 @@ Object ObjectFromXMLParser::parseObject(std::list<sax::Token>& input) const {
primitive::Primitive primitive = alib::api<primitive::Primitive>::parse(input);
Object res(std::move(primitive.getData()));
return res;
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "Void")) {
+ } else if(alib::api<Void>::first(input)) {
Object res(std::move(parseVoid(input)));
return res;
} else {
@@ -60,14 +60,14 @@ Object ObjectFromXMLParser::parseObject(std::list<sax::Token>& input) const {
}
Void ObjectFromXMLParser::parseVoid(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "Void");
- popToken(input, sax::Token::TokenType::END_ELEMENT, "Void");
+ 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(std::list<sax::Token>& input) {
- 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) || isToken(input, sax::Token::TokenType::START_ELEMENT, "Void");
+bool ObjectFromXMLParser::first(const std::list<sax::Token>& 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::api<Void>::first(input);
}
} /* namespace alib */
diff --git a/alib2data/src/object/ObjectFromXMLParser.h b/alib2data/src/object/ObjectFromXMLParser.h
index f2b0637bcea6f6ccee02e03023198f97cc2d22d1..85b5ac4626d0e84aaf51c6b3526dc83941f0b1ac 100644
--- a/alib2data/src/object/ObjectFromXMLParser.h
+++ b/alib2data/src/object/ObjectFromXMLParser.h
@@ -32,7 +32,7 @@ class ObjectFromXMLParser : public sax::FromXMLParserHelper {
template<typename T> friend class alib::api;
public:
- bool first(std::list<sax::Token>& input);
+ bool first(const std::list<sax::Token>& input) const;
};
} /* namespace alib */
diff --git a/alib2data/src/object/ObjectToXMLComposer.cpp b/alib2data/src/object/ObjectToXMLComposer.cpp
index 0fc9252f2d3971e42aa7b35ac3c2fff38ddbeccb..77a5915c98e7a81bcd65fd13a065c9732574ea37 100644
--- a/alib2data/src/object/ObjectToXMLComposer.cpp
+++ b/alib2data/src/object/ObjectToXMLComposer.cpp
@@ -19,8 +19,8 @@ std::list<sax::Token> ObjectToXMLComposer::compose(const Object& object) const {
std::list<sax::Token> ObjectToXMLComposer::compose(const Void&) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("Void", sax::Token::TokenType::START_ELEMENT));
- out.push_back(sax::Token("Void", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::ALIB_VOID, sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::ALIB_VOID, sax::Token::TokenType::END_ELEMENT));
return out;
}
diff --git a/alib2data/src/primitive/PrimitiveFromXMLParser.cpp b/alib2data/src/primitive/PrimitiveFromXMLParser.cpp
index 329fa9f96f37c298e3a71557d9b13c64a7e068ce..83dca2a06bb0ef35581408e060564bfa424cb723 100644
--- a/alib2data/src/primitive/PrimitiveFromXMLParser.cpp
+++ b/alib2data/src/primitive/PrimitiveFromXMLParser.cpp
@@ -10,6 +10,8 @@
#include <algorithm>
#include "../std/stou.h"
+#include "../Api.hpp"
+
namespace primitive {
Primitive PrimitiveFromXMLParser::parsePrimitive(std::list<sax::Token>& input) const {
@@ -17,13 +19,13 @@ Primitive PrimitiveFromXMLParser::parsePrimitive(std::list<sax::Token>& input) c
}
Primitive PrimitiveFromXMLParser::parsePrimitive(std::list<sax::Token>& input, const std::set<FEATURES>& features) const {
- if(isToken(input, sax::Token::TokenType::START_ELEMENT, "Integer")) {
+ if(alib::api<Integer>::first(input)) {
if(!features.count(FEATURES::INTEGER)) throw exception::AlibException();
return Primitive(parseInteger(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "String")) {
+ } else if(alib::api<String>::first(input)) {
if(!features.count(FEATURES::STRING)) throw exception::AlibException();
return Primitive(parseString(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "Character")) {
+ } else if(alib::api<Character>::first(input)) {
if(!features.count(FEATURES::CHAR)) throw exception::AlibException();
return Primitive(parseCharacter(input));
} else {
@@ -31,8 +33,8 @@ Primitive PrimitiveFromXMLParser::parsePrimitive(std::list<sax::Token>& input, c
}
}
-bool PrimitiveFromXMLParser::first(std::list<sax::Token>& input) const {
- if(isToken(input, sax::Token::TokenType::START_ELEMENT, "Integer") || isToken(input, sax::Token::TokenType::START_ELEMENT, "String") || isToken(input, sax::Token::TokenType::START_ELEMENT, "Character")) {
+bool PrimitiveFromXMLParser::first(const std::list<sax::Token>& input) const {
+ if(alib::api<Integer>::first(input) || alib::api<String>::first(input) || alib::api<Character>::first(input)) {
return true;
} else {
return false;
@@ -40,56 +42,56 @@ bool PrimitiveFromXMLParser::first(std::list<sax::Token>& input) const {
}
Integer PrimitiveFromXMLParser::parseInteger(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "Integer");
+ 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, "Integer");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::PRIMITIVE_INTEGER);
return data;
}
Character PrimitiveFromXMLParser::parseCharacter(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "Character");
+ 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, "Character");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::PRIMITIVE_CHARACTER);
return data;
}
String PrimitiveFromXMLParser::parseString(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "String");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::PRIMITIVE_STRING);
String data(popTokenData(input, sax::Token::TokenType::CHARACTER));
- popToken(input, sax::Token::TokenType::END_ELEMENT, "String");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::PRIMITIVE_STRING);
return data;
}
int PrimitiveFromXMLParser::parseIntegerRaw(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "Integer");
+ 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, "Integer");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::PRIMITIVE_INTEGER);
return data;
}
char PrimitiveFromXMLParser::parseCharacterRaw(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "Character");
+ 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, "Character");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::PRIMITIVE_CHARACTER);
return data;
}
std::string PrimitiveFromXMLParser::parseStringRaw(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "String");
+ 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, "String");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::PRIMITIVE_STRING);
return data;
}
unsigned PrimitiveFromXMLParser::parseUnsignedRaw(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "Unsigned");
+ 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, "Unsigned");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::PRIMITIVE_UNSIGNED);
return data;
}
bool PrimitiveFromXMLParser::parseBoolRaw(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "Bool");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::PRIMITIVE_BOOL);
std::string tmp = popTokenData(input, sax::Token::TokenType::CHARACTER);
bool data;
if(tmp == "true")
@@ -98,7 +100,7 @@ bool PrimitiveFromXMLParser::parseBoolRaw(std::list<sax::Token>& input) const {
data = false;
else
throw exception::AlibException("Invalid boolean value");
- popToken(input, sax::Token::TokenType::END_ELEMENT, "Bool");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::PRIMITIVE_BOOL);
return data;
}
diff --git a/alib2data/src/primitive/PrimitiveFromXMLParser.h b/alib2data/src/primitive/PrimitiveFromXMLParser.h
index 7c48fa8e1dec28a01dd003af1cdd8554c1020db9..b0538c5390ad687ca33fe1b4d3714f31dd5b6b72 100644
--- a/alib2data/src/primitive/PrimitiveFromXMLParser.h
+++ b/alib2data/src/primitive/PrimitiveFromXMLParser.h
@@ -45,7 +45,7 @@ class PrimitiveFromXMLParser : public sax::FromXMLParserHelper {
template<typename T> friend class alib::api;
public:
- bool first(std::list<sax::Token>& input) const;
+ bool first(const std::list<sax::Token>& input) const;
};
} /* namespace primitive */
diff --git a/alib2data/src/primitive/PrimitiveToXMLComposer.cpp b/alib2data/src/primitive/PrimitiveToXMLComposer.cpp
index 21710da13234f92951af13e6f358fb28b295ae4f..f38ad7759dd21bcbfbdd937ed7df9e093a545c75 100644
--- a/alib2data/src/primitive/PrimitiveToXMLComposer.cpp
+++ b/alib2data/src/primitive/PrimitiveToXMLComposer.cpp
@@ -30,68 +30,68 @@ std::list<sax::Token> PrimitiveToXMLComposer::compose(const PrimitiveBase& primi
std::list<sax::Token> PrimitiveToXMLComposer::compose(const Integer& primitive) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("Integer", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::PRIMITIVE_INTEGER, sax::Token::TokenType::START_ELEMENT));
out.push_back(sax::Token(std::itos(primitive.getData()), sax::Token::TokenType::CHARACTER));
- out.push_back(sax::Token("Integer", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::PRIMITIVE_INTEGER, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> PrimitiveToXMLComposer::compose(const Character& primitive) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("Character", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::PRIMITIVE_CHARACTER, sax::Token::TokenType::START_ELEMENT));
out.push_back(sax::Token(std::string(1, primitive.getData()), sax::Token::TokenType::CHARACTER));
- out.push_back(sax::Token("Character", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::PRIMITIVE_CHARACTER, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> PrimitiveToXMLComposer::compose(const String& primitive) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("String", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::PRIMITIVE_STRING, sax::Token::TokenType::START_ELEMENT));
out.push_back(sax::Token(primitive.getData(), sax::Token::TokenType::CHARACTER));
- out.push_back(sax::Token("String", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::PRIMITIVE_STRING, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> PrimitiveToXMLComposer::compose(int primitive) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("Integer", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::PRIMITIVE_INTEGER, sax::Token::TokenType::START_ELEMENT));
out.push_back(sax::Token(std::itos(primitive), sax::Token::TokenType::CHARACTER));
- out.push_back(sax::Token("Integer", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::PRIMITIVE_INTEGER, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> PrimitiveToXMLComposer::compose(char primitive) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("Character", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::PRIMITIVE_CHARACTER, sax::Token::TokenType::START_ELEMENT));
out.push_back(sax::Token(std::string(1, primitive), sax::Token::TokenType::CHARACTER));
- out.push_back(sax::Token("Character", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::PRIMITIVE_CHARACTER, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> PrimitiveToXMLComposer::compose(const std::string& primitive) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("String", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::PRIMITIVE_STRING, sax::Token::TokenType::START_ELEMENT));
out.push_back(sax::Token(primitive, sax::Token::TokenType::CHARACTER));
- out.push_back(sax::Token("String", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::PRIMITIVE_STRING, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> PrimitiveToXMLComposer::compose(unsigned primitive) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("Unsigned", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::PRIMITIVE_UNSIGNED, sax::Token::TokenType::START_ELEMENT));
out.push_back(sax::Token(std::utos(primitive), sax::Token::TokenType::CHARACTER));
- out.push_back(sax::Token("Unsigned", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::PRIMITIVE_UNSIGNED, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> PrimitiveToXMLComposer::compose(bool primitive) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("Bool", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::PRIMITIVE_BOOL, sax::Token::TokenType::START_ELEMENT));
if(primitive)
out.push_back(sax::Token("true", sax::Token::TokenType::END_ELEMENT));
else
out.push_back(sax::Token("false", sax::Token::TokenType::END_ELEMENT));
- out.push_back(sax::Token("Bool", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::PRIMITIVE_BOOL, sax::Token::TokenType::END_ELEMENT));
return out;
}
diff --git a/alib2data/src/regexp/RegExpFromXMLParser.cpp b/alib2data/src/regexp/RegExpFromXMLParser.cpp
index b255a26f85574cc7c49a586a24e2e5ba60ced310..47a410d354fb38b0697fa9e7a7f1d17dcc6b2ac6 100644
--- a/alib2data/src/regexp/RegExpFromXMLParser.cpp
+++ b/alib2data/src/regexp/RegExpFromXMLParser.cpp
@@ -17,18 +17,18 @@ RegExp RegExpFromXMLParser::parseRegExp(std::list<sax::Token>& input) const {
}
RegExp RegExpFromXMLParser::parseRegExp(std::list<sax::Token>& input, const std::set<FEATURES>& features) const {
- if(isToken(input, sax::Token::TokenType::START_ELEMENT, "unboundedRegexp")) {
+ if(alib::api<UnboundedRegExp>::first(input)) {
if(!features.count(FEATURES::UNBOUNDED)) throw exception::AlibException();
return RegExp(parseUnboundedRegExp(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "formalRegexp")) {
- if(!features.count(FEATURES::UNBOUNDED)) throw exception::AlibException();
+ } else if(alib::api<FormalRegExp>::first(input)) {
+ if(!features.count(FEATURES::FORMAL)) throw exception::AlibException();
return RegExp(parseFormalRegExp(input));
}
throw exception::AlibException();
}
-bool RegExpFromXMLParser::first(std::list<sax::Token>& input) const {
- if(isToken(input, sax::Token::TokenType::START_ELEMENT, "unboundedRegexp") || isToken(input, sax::Token::TokenType::START_ELEMENT, "formalRegexp")) {
+bool RegExpFromXMLParser::first(const std::list<sax::Token>& input) const {
+ if(alib::api<UnboundedRegExp>::first(input) || alib::api<FormalRegExp>::first(input)) {
return true;
} else {
return false;
@@ -36,7 +36,7 @@ bool RegExpFromXMLParser::first(std::list<sax::Token>& input) const {
}
UnboundedRegExp RegExpFromXMLParser::parseUnboundedRegExp(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "unboundedRegexp");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::REGEXP_UNBOUNDED_REGEXP);
UnboundedRegExp regexp;
parseAlphabet(input, regexp);
@@ -45,12 +45,12 @@ UnboundedRegExp RegExpFromXMLParser::parseUnboundedRegExp(std::list<sax::Token>&
regexp.setRegExp(std::move(*element));
delete element;
- popToken(input, sax::Token::TokenType::END_ELEMENT, "unboundedRegexp");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::REGEXP_UNBOUNDED_REGEXP);
return regexp;
}
FormalRegExp RegExpFromXMLParser::parseFormalRegExp(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "formalRegexp");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::REGEXP_FORMAL_REGEXP);
FormalRegExp regexp;
parseAlphabet(input, regexp);
@@ -59,7 +59,7 @@ FormalRegExp RegExpFromXMLParser::parseFormalRegExp(std::list<sax::Token>& input
regexp.setRegExp(std::move(*element));
delete element;
- popToken(input, sax::Token::TokenType::END_ELEMENT, "formalRegexp");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::REGEXP_FORMAL_REGEXP);
return regexp;
}
diff --git a/alib2data/src/regexp/RegExpFromXMLParser.h b/alib2data/src/regexp/RegExpFromXMLParser.h
index 9467dccfcfa3d41499c761a7141d12883cf5ae49..bc853497e98dc2054f07ff5b41d9e591e4a5fa72 100644
--- a/alib2data/src/regexp/RegExpFromXMLParser.h
+++ b/alib2data/src/regexp/RegExpFromXMLParser.h
@@ -56,7 +56,7 @@ class RegExpFromXMLParser : public sax::FromXMLParserHelper {
template<typename T> friend class alib::api;
public:
- bool first(std::list<sax::Token>& input) const;
+ bool first(const std::list<sax::Token>& input) const;
};
} /* namespace regexp */
diff --git a/alib2data/src/regexp/RegExpToXMLComposer.cpp b/alib2data/src/regexp/RegExpToXMLComposer.cpp
index 10a03c0eb1e20a801fe8d0bf0315b34e36967006..682e34053fc18f0c841aade509c9b76db948aa80 100644
--- a/alib2data/src/regexp/RegExpToXMLComposer.cpp
+++ b/alib2data/src/regexp/RegExpToXMLComposer.cpp
@@ -141,7 +141,7 @@ std::list<sax::Token> RegExpToXMLComposer::compose(const RegExpBase& regexp) con
std::list<sax::Token> RegExpToXMLComposer::compose(const UnboundedRegExp& regexp) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("unboundedRegexp", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::REGEXP_UNBOUNDED_REGEXP, sax::Token::TokenType::START_ELEMENT));
{
out.push_back(sax::Token("alphabet", sax::Token::TokenType::START_ELEMENT));
for (const auto& symbol: regexp.getAlphabet()) {
@@ -150,13 +150,13 @@ std::list<sax::Token> RegExpToXMLComposer::compose(const UnboundedRegExp& regexp
out.push_back(sax::Token("alphabet", sax::Token::TokenType::END_ELEMENT));
}
regexp.getRegExp().Accept((void*) &out, *this);
- out.push_back(sax::Token("unboundedRegexp", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::REGEXP_UNBOUNDED_REGEXP, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> RegExpToXMLComposer::compose(const FormalRegExp& regexp) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("formalRegexp", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::REGEXP_FORMAL_REGEXP, sax::Token::TokenType::START_ELEMENT));
{
out.push_back(sax::Token("alphabet", sax::Token::TokenType::START_ELEMENT));
for (const auto& symbol: regexp.getAlphabet()) {
@@ -165,7 +165,7 @@ std::list<sax::Token> RegExpToXMLComposer::compose(const FormalRegExp& regexp) c
out.push_back(sax::Token("alphabet", sax::Token::TokenType::END_ELEMENT));
}
regexp.getRegExp().Accept((void*) &out, *this);
- out.push_back(sax::Token("formalRegexp", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::REGEXP_FORMAL_REGEXP, sax::Token::TokenType::END_ELEMENT));
return out;
}
diff --git a/alib2data/src/sax/FromXMLParserHelper.cpp b/alib2data/src/sax/FromXMLParserHelper.cpp
index 9f0530826b71270e5733360f279497bd0cc98fc3..1bd60a367543e0a21bf1bc42b227595274d0aeb6 100644
--- a/alib2data/src/sax/FromXMLParserHelper.cpp
+++ b/alib2data/src/sax/FromXMLParserHelper.cpp
@@ -10,15 +10,15 @@
namespace sax {
-bool FromXMLParserHelper::isToken(std::list<Token>& input, Token::TokenType type, std::string data) const {
+bool FromXMLParserHelper::isToken(const std::list<Token>& input, Token::TokenType type, std::string data) {
return input.front().getType() == type && input.front().getData() == data;
}
-bool FromXMLParserHelper::isTokenType(std::list<Token>& input, Token::TokenType type) const {
+bool FromXMLParserHelper::isTokenType(const std::list<Token>& input, Token::TokenType type) {
return input.front().getType() == type;
}
-void FromXMLParserHelper::popToken(std::list<Token>& input, Token::TokenType type, std::string data) const {
+void FromXMLParserHelper::popToken(std::list<Token>& input, Token::TokenType type, std::string data) {
if (isToken(input, type, data)) {
input.pop_front();
} else {
@@ -26,7 +26,7 @@ void FromXMLParserHelper::popToken(std::list<Token>& input, Token::TokenType typ
}
}
-std::string FromXMLParserHelper::popTokenData(std::list<Token>& input, Token::TokenType type) const {
+std::string FromXMLParserHelper::popTokenData(std::list<Token>& input, Token::TokenType type) {
if(isTokenType(input, type)) {
std::string result = input.front().getData();
input.pop_front();
diff --git a/alib2data/src/sax/FromXMLParserHelper.h b/alib2data/src/sax/FromXMLParserHelper.h
index c31def439bac3819a983b0e891366160846aae38..ad85e3d317496af9f4e2f8f82526d32ec229fa8b 100644
--- a/alib2data/src/sax/FromXMLParserHelper.h
+++ b/alib2data/src/sax/FromXMLParserHelper.h
@@ -17,11 +17,11 @@ namespace sax {
* Parser used to get UnknownAutomaton from XML parsed into list of Tokens.
*/
class FromXMLParserHelper {
-protected:
- bool isToken(std::list<Token> &input, Token::TokenType type, std::string data) const;
- bool isTokenType(std::list<Token>& input, Token::TokenType type) const;
- void popToken(std::list<Token> &input, Token::TokenType type, std::string data) const;
- std::string popTokenData(std::list<Token>& input, Token::TokenType type) const;
+public:
+ static bool isToken(const std::list<Token>& input, Token::TokenType type, std::string data);
+ static bool isTokenType(const std::list<Token>& input, Token::TokenType type);
+ static void popToken(std::list<Token>& input, Token::TokenType type, std::string data);
+ static std::string popTokenData(std::list<Token>& input, Token::TokenType type);
};
diff --git a/alib2data/src/string/StringFromXMLParser.cpp b/alib2data/src/string/StringFromXMLParser.cpp
index 47faea16f1173834963dca11a1d5c56caec8c982..7ac495e7abea959f848be690d76461e8b9b2c7e5 100644
--- a/alib2data/src/string/StringFromXMLParser.cpp
+++ b/alib2data/src/string/StringFromXMLParser.cpp
@@ -17,13 +17,13 @@ String StringFromXMLParser::parseString(std::list<sax::Token>& input) const {
}
String StringFromXMLParser::parseString(std::list<sax::Token>& input, const std::set<FEATURES>& features) const {
- if(isToken(input, sax::Token::TokenType::START_ELEMENT, "Epsilon")) {
+ if(alib::api<Epsilon>::first(input)) {
if(!features.count(FEATURES::EPSILON)) throw exception::AlibException();
return String(parseEpsilon(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "LinearString")) {
+ } else if(alib::api<LinearString>::first(input)) {
if(!features.count(FEATURES::LINEAR)) throw exception::AlibException();
return String(parseLinearString(input));
- } else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "CyclicString")) {
+ } else if(alib::api<CyclicString>::first(input)) {
if(!features.count(FEATURES::CYCLIC)) throw exception::AlibException();
return String(parseCyclicString(input));
} else {
@@ -31,8 +31,8 @@ String StringFromXMLParser::parseString(std::list<sax::Token>& input, const std:
}
}
-bool StringFromXMLParser::first(std::list<sax::Token>& input) const {
- if(isToken(input, sax::Token::TokenType::START_ELEMENT, "Epsilon") || isToken(input, sax::Token::TokenType::START_ELEMENT, "LinearString") || isToken(input, sax::Token::TokenType::START_ELEMENT, "CyclicString")) {
+bool StringFromXMLParser::first(const std::list<sax::Token>& input) const {
+ if(alib::api<Epsilon>::first(input) || alib::api<LinearString>::first(input) || alib::api<CyclicString>::first(input)) {
return true;
} else {
return false;
@@ -40,7 +40,7 @@ bool StringFromXMLParser::first(std::list<sax::Token>& input) const {
}
LinearString StringFromXMLParser::parseLinearString(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "LinearString");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::STRING_LINEAR_STRING);
LinearString string;
std::set<alphabet::Symbol> alphabet = parseAlphabet(input);
@@ -49,12 +49,12 @@ LinearString StringFromXMLParser::parseLinearString(std::list<sax::Token>& input
std::vector<alphabet::Symbol> data = parseContentData(input);
string.setContent(data);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "LinearString");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::STRING_LINEAR_STRING);
return string;
}
CyclicString StringFromXMLParser::parseCyclicString(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "CyclicString");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::STRING_CYCLIC_STRING);
CyclicString string;
std::set<alphabet::Symbol> alphabet = parseAlphabet(input);
@@ -63,18 +63,18 @@ CyclicString StringFromXMLParser::parseCyclicString(std::list<sax::Token>& input
std::vector<alphabet::Symbol> data = parseContentData(input);
string.setContent(data);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "CyclicString");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::STRING_CYCLIC_STRING);
return string;
}
Epsilon StringFromXMLParser::parseEpsilon(std::list<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "Epsilon");
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::STRING_EPSILON);
Epsilon epsilon;
std::set<alphabet::Symbol> alphabet = parseAlphabet(input);
epsilon.setAlphabet(alphabet);
- popToken(input, sax::Token::TokenType::END_ELEMENT, "Epsilon");
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::STRING_EPSILON);
return epsilon;
}
diff --git a/alib2data/src/string/StringFromXMLParser.h b/alib2data/src/string/StringFromXMLParser.h
index 3f8fe1ce5bfa2ab99bfb78316024648cd87e0838..ea0663380e67ab18f3b205effe1e758e70c2d292 100644
--- a/alib2data/src/string/StringFromXMLParser.h
+++ b/alib2data/src/string/StringFromXMLParser.h
@@ -44,7 +44,7 @@ class StringFromXMLParser : public sax::FromXMLParserHelper {
template<typename T> friend class alib::api;
public:
- bool first(std::list<sax::Token>& input) const;
+ bool first(const std::list<sax::Token>& input) const;
};
} /* namespace string */
diff --git a/alib2data/src/string/StringToXMLComposer.cpp b/alib2data/src/string/StringToXMLComposer.cpp
index f45545a17d0ef0f402bdb77ac801db6e4f6da6ba..240a4bccb54fd22b64a93a0a26eabe14974c64c0 100644
--- a/alib2data/src/string/StringToXMLComposer.cpp
+++ b/alib2data/src/string/StringToXMLComposer.cpp
@@ -28,7 +28,7 @@ std::list<sax::Token> StringToXMLComposer::compose(const StringBase& string) con
std::list<sax::Token> StringToXMLComposer::compose(const LinearString& string) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("LinearString", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::STRING_LINEAR_STRING, sax::Token::TokenType::START_ELEMENT));
out.push_back(sax::Token("alphabet", sax::Token::TokenType::START_ELEMENT));
for (const auto& symbol: string.getAlphabet()) {
out.splice(out.end(), alib::api<alphabet::Symbol>::compose(symbol));
@@ -38,13 +38,13 @@ std::list<sax::Token> StringToXMLComposer::compose(const LinearString& string) c
for(const auto& symbol : string.getContent()) {
out.splice(out.end(), alib::api<alphabet::Symbol>::compose(symbol));
}
- out.push_back(sax::Token("LinearString", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::STRING_LINEAR_STRING, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> StringToXMLComposer::compose(const CyclicString& string) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("CyclicString", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::STRING_CYCLIC_STRING, sax::Token::TokenType::START_ELEMENT));
out.push_back(sax::Token("alphabet", sax::Token::TokenType::START_ELEMENT));
for (const auto& symbol: string.getAlphabet()) {
out.splice(out.end(), alib::api<alphabet::Symbol>::compose(symbol));
@@ -54,19 +54,19 @@ std::list<sax::Token> StringToXMLComposer::compose(const CyclicString& string) c
for(const auto& symbol : string.getContent()) {
out.splice(out.end(), alib::api<alphabet::Symbol>::compose(symbol));
}
- out.push_back(sax::Token("CyclicString", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::STRING_CYCLIC_STRING, sax::Token::TokenType::END_ELEMENT));
return out;
}
std::list<sax::Token> StringToXMLComposer::compose(const Epsilon& string) const {
std::list<sax::Token> out;
- out.push_back(sax::Token("Epsilon", sax::Token::TokenType::START_ELEMENT));
+ out.push_back(sax::Token(alib::Names::STRING_EPSILON, sax::Token::TokenType::START_ELEMENT));
out.push_back(sax::Token("alphabet", sax::Token::TokenType::START_ELEMENT));
for (const auto& symbol: string.getAlphabet()) {
out.splice(out.end(), alib::api<alphabet::Symbol>::compose(symbol));
}
out.push_back(sax::Token("alphabet", sax::Token::TokenType::END_ELEMENT));
- out.push_back(sax::Token("Epsilon", sax::Token::TokenType::END_ELEMENT));
+ out.push_back(sax::Token(alib::Names::STRING_EPSILON, sax::Token::TokenType::END_ELEMENT));
return out;
}
diff --git a/examples2/regexp/Melichar2-94.i0.xml b/examples2/regexp/Melichar2-94.i0.xml
index f2c4ec198f49bc67312efffff98420fab784c4f0..46501d1c8ce9ca93469818983a232735ab5cc540 100644
--- a/examples2/regexp/Melichar2-94.i0.xml
+++ b/examples2/regexp/Melichar2-94.i0.xml
@@ -1,4 +1,4 @@
-<unboundedRegexp>
+<UnboundedRegExp>
<alphabet>
<LabeledSymbol><PrimitiveLabel><Integer>0</Integer></PrimitiveLabel></LabeledSymbol>
<LabeledSymbol><PrimitiveLabel><Integer>1</Integer></PrimitiveLabel></LabeledSymbol>
@@ -13,4 +13,4 @@
</iteration>
<LabeledSymbol><PrimitiveLabel><Integer>1</Integer></PrimitiveLabel></LabeledSymbol>
</concatenation>
-</unboundedRegexp>
+</UnboundedRegExp>
diff --git a/examples2/regexp/Melichar2-94.i1.xml b/examples2/regexp/Melichar2-94.i1.xml
index 1fa54da20066adc9c6e3ce49cbfe6e7d01e097df..6c4b21a4c1bba56deb0fb145e79b229c1256c49b 100644
--- a/examples2/regexp/Melichar2-94.i1.xml
+++ b/examples2/regexp/Melichar2-94.i1.xml
@@ -1,4 +1,4 @@
-<unboundedRegexp>
+<UnboundedRegExp>
<alphabet>
<LabeledSymbol><PrimitiveLabel><Integer>0</Integer></PrimitiveLabel></LabeledSymbol>
<LabeledSymbol><PrimitiveLabel><Integer>1</Integer></PrimitiveLabel></LabeledSymbol>
@@ -13,4 +13,4 @@
</iteration>
<LabeledSymbol><PrimitiveLabel><Integer>1</Integer></PrimitiveLabel></LabeledSymbol>
</concatenation>
-</unboundedRegexp>
+</UnboundedRegExp>
diff --git a/examples2/regexp/Melichar2-94.xml b/examples2/regexp/Melichar2-94.xml
index 731f2a4709d433f4bd3b4cbf5ac37df3de724364..890443b6a4310b1ec2996162b9906b18d98b1d28 100644
--- a/examples2/regexp/Melichar2-94.xml
+++ b/examples2/regexp/Melichar2-94.xml
@@ -1,4 +1,4 @@
-<unboundedRegexp>
+<UnboundedRegExp>
<alphabet>
<LabeledSymbol><PrimitiveLabel><Integer>0</Integer></PrimitiveLabel></LabeledSymbol>
<LabeledSymbol><PrimitiveLabel><Integer>1</Integer></PrimitiveLabel></LabeledSymbol>
@@ -12,4 +12,4 @@
</iteration>
<LabeledSymbol><PrimitiveLabel><Integer>1</Integer></PrimitiveLabel></LabeledSymbol>
</concatenation>
-</unboundedRegexp>
+</UnboundedRegExp>
diff --git a/examples2/regexp/formal-aag.oppa.4.13.xml b/examples2/regexp/formal-aag.oppa.4.13.xml
index 9eddb3bf90511de46aebb096e4d28bbf25c54b22..3db70ab8f15e123a26b86056c7abd7b06f115635 100644
--- a/examples2/regexp/formal-aag.oppa.4.13.xml
+++ b/examples2/regexp/formal-aag.oppa.4.13.xml
@@ -1,4 +1,4 @@
-<formalRegexp>
+<FormalRegExp>
<alphabet>
<LabeledSymbol><PrimitiveLabel><Integer>0</Integer></PrimitiveLabel></LabeledSymbol>
<LabeledSymbol><PrimitiveLabel><Integer>1</Integer></PrimitiveLabel></LabeledSymbol>
@@ -35,4 +35,4 @@
</alternation>
</alternation>
</alternation>
-</formalRegexp>
+</FormalRegExp>
diff --git a/examples2/regexp/formal-aag.oppa.4.14.xml b/examples2/regexp/formal-aag.oppa.4.14.xml
index cc5b84bd170190451be6862545662604e689411c..fbbbbfd9555242537b1b0704da1a1e7d142b6e87 100644
--- a/examples2/regexp/formal-aag.oppa.4.14.xml
+++ b/examples2/regexp/formal-aag.oppa.4.14.xml
@@ -1,4 +1,4 @@
-<unboundedRegexp>
+<UnboundedRegExp>
<alphabet>
<LabeledSymbol><PrimitiveLabel><Integer>0</Integer></PrimitiveLabel></LabeledSymbol>
<LabeledSymbol><PrimitiveLabel><Integer>1</Integer></PrimitiveLabel></LabeledSymbol>
@@ -20,4 +20,4 @@
</concatenation>
</alternation>
</iteration>
-</unboundedRegexp>
+</UnboundedRegExp>
diff --git a/examples2/regexp/regexp.xml b/examples2/regexp/regexp.xml
index b7e34b3c518e8fc1852b8f03d5786e7075a08c4e..d23d63e18f00a157679defe6c4a4b2b1aa9e4248 100644
--- a/examples2/regexp/regexp.xml
+++ b/examples2/regexp/regexp.xml
@@ -1,4 +1,4 @@
-<unboundedRegexp>
+<UnboundedRegExp>
<alphabet>
<LabeledSymbol><PrimitiveLabel><Integer>0</Integer></PrimitiveLabel></LabeledSymbol>
<LabeledSymbol><PrimitiveLabel><Integer>1</Integer></PrimitiveLabel></LabeledSymbol>
diff --git a/examples2/regexp/regexp2.xml b/examples2/regexp/regexp2.xml
index 1593a027d26998d8ce2f549f49a0bcde7c50f814..416b2944d424f1854b076db29ea6696db176d89b 100644
--- a/examples2/regexp/regexp2.xml
+++ b/examples2/regexp/regexp2.xml
@@ -1,4 +1,4 @@
-<unboundedRegexp>
+<UnboundedRegExp>
<alphabet>
<LabeledSymbol><PrimitiveLabel><Integer>0</Integer></PrimitiveLabel></LabeledSymbol>
<LabeledSymbol><PrimitiveLabel><Integer>1</Integer></PrimitiveLabel></LabeledSymbol>
diff --git a/examples2/regexp/regexp3.xml b/examples2/regexp/regexp3.xml
index ec2de6c97aa2e375f62af23ae01fbe70b7670645..f21b3ac3a416896838cc1b040837cd6290881acc 100644
--- a/examples2/regexp/regexp3.xml
+++ b/examples2/regexp/regexp3.xml
@@ -1,4 +1,4 @@
-<regexp>
+<UnboundedRegExp>
<alphabet>
<LabeledSymbol><PrimitiveLabel><String>We</String></PrimitiveLabel></LabeledSymbol>
<LabeledSymbol><PrimitiveLabel><String>have</String></PrimitiveLabel></LabeledSymbol>
@@ -33,4 +33,4 @@
</iteration>
</iteration>
</iteration>
-</regexp>
+</UnboundedRegExp>
diff --git a/examples2/regexp/regexp4.xml b/examples2/regexp/regexp4.xml
index 3cb65a3158b24b2cd9c93cd38afb4530c5d46e13..66d982807e4e1dc6233db9313d3c2a74a262eda0 100644
--- a/examples2/regexp/regexp4.xml
+++ b/examples2/regexp/regexp4.xml
@@ -1,4 +1,4 @@
-<unboundedRegexp>
+<UnboundedRegExp>
<alphabet>
<LabeledSymbol><PrimitiveLabel><Integer>0</Integer></PrimitiveLabel></LabeledSymbol>
<LabeledSymbol><PrimitiveLabel><Integer>1</Integer></PrimitiveLabel></LabeledSymbol>
diff --git a/examples2/regexp/unbounded.oppa.4.13.d0.xml b/examples2/regexp/unbounded.oppa.4.13.d0.xml
index da1209071608ce5069f84f3e816be91c8324f84a..6f16fd749babe10bc4595154b2c61133832783c3 100644
--- a/examples2/regexp/unbounded.oppa.4.13.d0.xml
+++ b/examples2/regexp/unbounded.oppa.4.13.d0.xml
@@ -1,4 +1,4 @@
-<unboundedRegexp>
+<UnboundedRegExp>
<alphabet>
<LabeledSymbol><PrimitiveLabel><Integer>0</Integer></PrimitiveLabel></LabeledSymbol>
<LabeledSymbol><PrimitiveLabel><Integer>1</Integer></PrimitiveLabel></LabeledSymbol>
@@ -16,4 +16,4 @@
</concatenation>
<epsilon></epsilon>
</alternation>
-</unboundedRegexp>
+</UnboundedRegExp>
diff --git a/examples2/regexp/unbounded.oppa.4.13.d00.xml b/examples2/regexp/unbounded.oppa.4.13.d00.xml
index 3d9e8870681fb7215c6d8c0fb5d40947eb7e391d..3bb2e02aebefce5d6202796e17b69fe9f2dd542b 100644
--- a/examples2/regexp/unbounded.oppa.4.13.d00.xml
+++ b/examples2/regexp/unbounded.oppa.4.13.d00.xml
@@ -1,4 +1,4 @@
-<unboundedRegexp>
+<UnboundedRegExp>
<alphabet>
<LabeledSymbol><PrimitiveLabel><Integer>0</Integer></PrimitiveLabel></LabeledSymbol>
<LabeledSymbol><PrimitiveLabel><Integer>1</Integer></PrimitiveLabel></LabeledSymbol>
@@ -11,4 +11,4 @@
<LabeledSymbol><PrimitiveLabel><Integer>1</Integer></PrimitiveLabel></LabeledSymbol>
</concatenation>
</alternation>
-</unboundedRegexp>
+</UnboundedRegExp>
diff --git a/examples2/regexp/unbounded.oppa.4.13.xml b/examples2/regexp/unbounded.oppa.4.13.xml
index e23336c11daa1bf1222e552de4a4607a6ff083d8..31bdad1d3eeb50b32fd092096a67fda6c09be4d5 100644
--- a/examples2/regexp/unbounded.oppa.4.13.xml
+++ b/examples2/regexp/unbounded.oppa.4.13.xml
@@ -1,4 +1,4 @@
-<unboundedRegexp>
+<UnboundedRegExp>
<alphabet>
<LabeledSymbol><PrimitiveLabel><Integer>0</Integer></PrimitiveLabel></LabeledSymbol>
<LabeledSymbol><PrimitiveLabel><Integer>1</Integer></PrimitiveLabel></LabeledSymbol>
@@ -27,4 +27,4 @@
<LabeledSymbol><PrimitiveLabel><Integer>0</Integer></PrimitiveLabel></LabeledSymbol>
</concatenation>
</alternation>
-</unboundedRegexp>
+</UnboundedRegExp>
diff --git a/examples2/regexp/unbounded.oppa.4.14.d1.xml b/examples2/regexp/unbounded.oppa.4.14.d1.xml
index ce3e635c23500e5791b70ad7548b0f3f13e10111..2506ede2b284132cdff16243433745bd4c06d2f9 100644
--- a/examples2/regexp/unbounded.oppa.4.14.d1.xml
+++ b/examples2/regexp/unbounded.oppa.4.14.d1.xml
@@ -1,4 +1,4 @@
-<unboundedRegexp>
+<UnboundedRegExp>
<alphabet>
<LabeledSymbol><PrimitiveLabel><Integer>0</Integer></PrimitiveLabel></LabeledSymbol>
<LabeledSymbol><PrimitiveLabel><Integer>1</Integer></PrimitiveLabel></LabeledSymbol>
@@ -25,4 +25,4 @@
</alternation>
</iteration>
</concatenation>
-</unboundedRegexp>
+</UnboundedRegExp>
diff --git a/examples2/regexp/unbounded.oppa.4.14.d10.xml b/examples2/regexp/unbounded.oppa.4.14.d10.xml
index 16f580c1e643ce1042e8155f79a3b24c2af0fb82..d9ec8f89bd49039009fbc0dabeb5d4bb0502734b 100644
--- a/examples2/regexp/unbounded.oppa.4.14.d10.xml
+++ b/examples2/regexp/unbounded.oppa.4.14.d10.xml
@@ -1,4 +1,4 @@
-<unboundedRegexp>
+<UnboundedRegExp>
<alphabet>
<LabeledSymbol><PrimitiveLabel><Integer>0</Integer></PrimitiveLabel></LabeledSymbol>
<LabeledSymbol><PrimitiveLabel><Integer>1</Integer></PrimitiveLabel></LabeledSymbol>
@@ -33,4 +33,4 @@
</alternation>
</iteration>
</concatenation>
-</unboundedRegexp>
+</UnboundedRegExp>
diff --git a/examples2/regexp/unbounded.oppa.4.14.xml b/examples2/regexp/unbounded.oppa.4.14.xml
index dfa486ca6f448f07e7288d765c40d8408f9329a0..599460023607df5a66798a0b976ff024658447c4 100644
--- a/examples2/regexp/unbounded.oppa.4.14.xml
+++ b/examples2/regexp/unbounded.oppa.4.14.xml
@@ -1,4 +1,4 @@
-<unboundedRegexp>
+<UnboundedRegExp>
<alphabet>
<LabeledSymbol><PrimitiveLabel><Integer>0</Integer></PrimitiveLabel></LabeledSymbol>
<LabeledSymbol><PrimitiveLabel><Integer>1</Integer></PrimitiveLabel></LabeledSymbol>
@@ -20,4 +20,4 @@
</concatenation>
</alternation>
</iteration>
-</unboundedRegexp>
+</UnboundedRegExp>
diff --git a/examples2/regexp/unbounded.oppa.4.15.d100.xml b/examples2/regexp/unbounded.oppa.4.15.d100.xml
index 8fdd212000ee879703b3933b0ca22564afc989ca..373baa53a29c122c1f5fa8daa6df479a1db54420 100644
--- a/examples2/regexp/unbounded.oppa.4.15.d100.xml
+++ b/examples2/regexp/unbounded.oppa.4.15.d100.xml
@@ -1,4 +1,4 @@
-<unboundedRegexp>
+<UnboundedRegExp>
<alphabet>
<LabeledSymbol><PrimitiveLabel><Integer>0</Integer></PrimitiveLabel></LabeledSymbol>
<LabeledSymbol><PrimitiveLabel><Integer>1</Integer></PrimitiveLabel></LabeledSymbol>
@@ -15,4 +15,4 @@
</concatenation>
<epsilon></epsilon>
</alternation>
-</unboundedRegexp>
+</UnboundedRegExp>
diff --git a/examples2/regexp/unbounded.oppa.4.15.xml b/examples2/regexp/unbounded.oppa.4.15.xml
index 9bfc08f3190d96173840b6b35ecb369f401eb3b8..9d33898b2efc38f0e50786f31e6099f2cc7a5a95 100644
--- a/examples2/regexp/unbounded.oppa.4.15.xml
+++ b/examples2/regexp/unbounded.oppa.4.15.xml
@@ -1,4 +1,4 @@
-<unboundedRegexp>
+<UnboundedRegExp>
<alphabet>
<LabeledSymbol><PrimitiveLabel><Integer>0</Integer></PrimitiveLabel></LabeledSymbol>
<LabeledSymbol><PrimitiveLabel><Integer>1</Integer></PrimitiveLabel></LabeledSymbol>
@@ -13,4 +13,4 @@
</iteration>
<LabeledSymbol><PrimitiveLabel><Integer>0</Integer></PrimitiveLabel></LabeledSymbol>
</concatenation>
-</unboundedRegexp>
+</UnboundedRegExp>
diff --git a/examples2/regexp/unbounded.oppa.4.16.i1.xml b/examples2/regexp/unbounded.oppa.4.16.i1.xml
index 7140d14893a2b7fefbe9b5983ab1e1825553ed83..68aa7a0efeba640bbc1b4cd34609b1de4c650a9a 100644
--- a/examples2/regexp/unbounded.oppa.4.16.i1.xml
+++ b/examples2/regexp/unbounded.oppa.4.16.i1.xml
@@ -1,4 +1,4 @@
-<unboundedRegexp>
+<UnboundedRegExp>
<alphabet>
<LabeledSymbol><PrimitiveLabel><Integer>0</Integer></PrimitiveLabel></LabeledSymbol>
<LabeledSymbol><PrimitiveLabel><Integer>1</Integer></PrimitiveLabel></LabeledSymbol>
@@ -17,4 +17,4 @@
<LabeledSymbol><PrimitiveLabel><Integer>1</Integer></PrimitiveLabel></LabeledSymbol>
</concatenation>
</alternation>
-</unboundedRegexp>
+</UnboundedRegExp>
diff --git a/examples2/regexp/unbounded.oppa.4.16.xml b/examples2/regexp/unbounded.oppa.4.16.xml
index c7fe8d6a6bdad99c6a4c0d9de78f900c78e3851f..68be01d4863303939ff425217979f5492b0d07cf 100644
--- a/examples2/regexp/unbounded.oppa.4.16.xml
+++ b/examples2/regexp/unbounded.oppa.4.16.xml
@@ -1,4 +1,4 @@
-<unboundedRegexp>
+<UnboundedRegExp>
<alphabet>
<LabeledSymbol><PrimitiveLabel><Integer>0</Integer></PrimitiveLabel></LabeledSymbol>
<LabeledSymbol><PrimitiveLabel><Integer>1</Integer></PrimitiveLabel></LabeledSymbol>
@@ -15,4 +15,4 @@
<LabeledSymbol><PrimitiveLabel><Integer>1</Integer></PrimitiveLabel></LabeledSymbol>
</concatenation>
</alternation>
-</unboundedRegexp>
+</UnboundedRegExp>