primitive raw parsers and composers

alib2data/src/Api.cpp

@@ -535,6 +535,14 @@ std::list<sax::Token> api<primitive::String>::compose(const primitive::String& d
 	return ToXMLComposers::primitiveComposer.compose(data);
 }
+std::string api<std::string>::parse(std::list<sax::Token>& input) {
+	return FromXMLParsers::primitiveParser.parseStringRaw(input);
+}
+
+std::list<sax::Token> api<std::string>::compose(const std::string& data) {
+	return ToXMLComposers::primitiveComposer.compose(data);
+}
+
 primitive::Integer api<primitive::Integer>::parse(std::list<sax::Token>& input) {
 	return FromXMLParsers::primitiveParser.parseInteger(input);
 }
@@ -543,6 +551,14 @@ std::list<sax::Token> api<primitive::Integer>::compose(const primitive::Integer&
 	return ToXMLComposers::primitiveComposer.compose(data);
 }
+int api<int>::parse(std::list<sax::Token>& input) {
+	return FromXMLParsers::primitiveParser.parseIntegerRaw(input);
+}
+
+std::list<sax::Token> api<int>::compose(int data) {
+	return ToXMLComposers::primitiveComposer.compose(data);
+}
+
 primitive::Character api<primitive::Character>::parse(std::list<sax::Token>& input) {
 	return FromXMLParsers::primitiveParser.parseCharacter(input);
 }
@@ -551,6 +567,29 @@ std::list<sax::Token> api<primitive::Character>::compose(const primitive::Charac
 	return ToXMLComposers::primitiveComposer.compose(data);
 }
+char api<char>::parse(std::list<sax::Token>& input) {
+	return FromXMLParsers::primitiveParser.parseCharacterRaw(input);
+}
+
+std::list<sax::Token> api<char>::compose(char data) {
+	return ToXMLComposers::primitiveComposer.compose(data);
+}
+
+unsigned api<unsigned>::parse(std::list<sax::Token>& input) {
+	return FromXMLParsers::primitiveParser.parseCharacterRaw(input);
+}
+
+std::list<sax::Token> api<unsigned>::compose(unsigned data) {
+	return ToXMLComposers::primitiveComposer.compose(data);
+}
+
+bool api<bool>::parse(std::list<sax::Token>& input) {
+	return FromXMLParsers::primitiveParser.parseCharacterRaw(input);
+}
+
+std::list<sax::Token> api<bool>::compose(bool data) {
+	return ToXMLComposers::primitiveComposer.compose(data);
+}
 void ToXMLComposers::Visit(void* data, const Void& voidObject) const {
 	*((std::list<sax::Token>*) data) = std::move(api<Void>::compose(voidObject));

alib2data/src/Api.hpp

@@ -436,18 +436,48 @@ struct api<primitive::String> {
 	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 std::list<sax::Token> compose(const std::string& data);
+};
+
 template<>
 struct api<primitive::Integer> {
 	static primitive::Integer parse(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 std::list<sax::Token> compose(int data);
+};
+
 template<>
 struct api<primitive::Character> {
 	static primitive::Character parse(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 std::list<sax::Token> compose(char data);
+};
+
+template<>
+struct api<unsigned> {
+	static unsigned parse(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 std::list<sax::Token> compose(bool data);
+};
+
 } /* namespace alib */
 #include "container/ContainerFromXMLParser.hpp"

alib2data/src/primitive/PrimitiveFromXMLParser.cpp

@@ -8,6 +8,7 @@
 #include "PrimitiveFromXMLParser.h"
 #include "../sax/ParserException.h"
 #include <algorithm>
+#include "../std/stou.h"
 namespace primitive {
@@ -59,4 +60,46 @@ String PrimitiveFromXMLParser::parseString(std::list<sax::Token>& input) const {
 	return data;
 }
+int PrimitiveFromXMLParser::parseIntegerRaw(std::list<sax::Token>& input) const {
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "Integer");
+	int data = std::stoi(popTokenData(input, sax::Token::TokenType::CHARACTER));
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "Integer");
+	return data;
+}
+
+char PrimitiveFromXMLParser::parseCharacterRaw(std::list<sax::Token>& input) const {
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "Character");
+	char data = popTokenData(input, sax::Token::TokenType::CHARACTER)[0];
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "Character");
+	return data;
+}
+
+std::string PrimitiveFromXMLParser::parseStringRaw(std::list<sax::Token>& input) const {
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "String");
+	std::string data = popTokenData(input, sax::Token::TokenType::CHARACTER);
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "String");
+	return data;
+}
+
+unsigned PrimitiveFromXMLParser::parseUnsignedRaw(std::list<sax::Token>& input) const {
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "Unsigned");
+	unsigned data = std::stou(popTokenData(input, sax::Token::TokenType::CHARACTER));
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "Unsigned");
+	return data;
+}
+
+bool PrimitiveFromXMLParser::parseBoolRaw(std::list<sax::Token>& input) const {
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "Bool");
+	std::string tmp = popTokenData(input, sax::Token::TokenType::CHARACTER);
+	bool data;
+	if(tmp == "true")
+		data = true;
+	else if(tmp == "false")
+		data = false;
+	else
+		throw exception::AlibException("Invalid boolean value");
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "Bool");
+	return data;
+}
+
 } /* namespace primitive */

alib2data/src/primitive/PrimitiveFromXMLParser.h

@@ -37,6 +37,12 @@ class PrimitiveFromXMLParser : public sax::FromXMLParserHelper {
 	Character parseCharacter(std::list<sax::Token>& input) const;
 	String parseString(std::list<sax::Token>& input) const;
+	int parseIntegerRaw(std::list<sax::Token>& input) const;
+	char parseCharacterRaw(std::list<sax::Token>& input) const;
+	std::string parseStringRaw(std::list<sax::Token>& input) const;
+	unsigned parseUnsignedRaw(std::list<sax::Token>& input) const;
+	bool parseBoolRaw(std::list<sax::Token>& input) const;
+
 	template<typename T> friend class alib::api;
 public:
 	bool first(std::list<sax::Token>& input) const;

alib2data/src/primitive/PrimitiveToXMLComposer.cpp

@@ -10,6 +10,7 @@
 #include "String.h"
 #include "Character.h"
 #include "../std/itos.h"
+#include "../std/utos.h"
 #include "../Api.hpp"
@@ -51,4 +52,47 @@ std::list<sax::Token> PrimitiveToXMLComposer::compose(const String& primitive) c
 	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(std::itos(primitive), sax::Token::TokenType::CHARACTER));
+	out.push_back(sax::Token("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(std::string(1, primitive), sax::Token::TokenType::CHARACTER));
+	out.push_back(sax::Token("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(primitive, sax::Token::TokenType::CHARACTER));
+	out.push_back(sax::Token("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(std::utos(primitive), sax::Token::TokenType::CHARACTER));
+	out.push_back(sax::Token("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));
+	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));
+	return out;
+}
+
 } /* namespace primitive */

alib2data/src/primitive/PrimitiveToXMLComposer.h

@@ -9,6 +9,7 @@
 #define PRIMITIVE_TO_XML_COMPOSER_H_
 #include <list>
+#include <string>
 #include "Primitive.h"
 #include "../sax/Token.h"
@@ -44,6 +45,12 @@ class PrimitiveToXMLComposer {
 	std::list<sax::Token> compose(const Integer& primitive) const;
 	std::list<sax::Token> compose(const Character& primitive) const;
+	std::list<sax::Token> compose(const std::string& primitive) const;
+	std::list<sax::Token> compose(int primitive) const;
+	std::list<sax::Token> compose(char primitive) const;
+	std::list<sax::Token> compose(unsigned primitive) const;
+	std::list<sax::Token> compose(bool primitive) const;
+
 	template<typename T> friend class alib::api;
 };

alib2data/src/std/stou.cpp

+#include "stou.h"
+
+namespace std {
+
+unsigned stou(const std::string& string, int) {
+	stringstream ss(string);
+	unsigned integer;
+	ss >> integer;
+	return integer;
+}
+
+}

alib2data/src/std/stou.h

+#ifndef STOU_H_
+#define STOU_H_
+
+#include <sstream>
+#include <string>
+
+namespace std {
+
+unsigned stou(const std::string&, int base = 10);
+
+} /* namespace std */
+
+#endif /* STOU_H_ */

alib2data/src/std/utos.cpp

+#include "utos.h"
+
+namespace std {
+
+string utos(unsigned integer, int) {
+	stringstream ss;
+	ss << integer;
+	return ss.str();
+}
+
+}

alib2data/src/std/utos.h

+#ifndef UTOS_H_
+#define UTOS_H_
+
+#include <sstream>
+#include <string>
+
+namespace std {
+
+string utos(unsigned integer, int base = 10);
+
+} /* namespace std */
+
+#endif /* UTOS_H_ */

arun2/src/arun.cpp

@@ -50,21 +50,13 @@ int main(int argc, char* argv[]) {
 			string::LinearString input = alib::DataFactory::fromTokens<string::LinearString>(inputTokens);
 			automaton::Automaton automaton = alib::DataFactory::fromTokens<automaton::Automaton>(automatonTokens);
 			std::set<unsigned> res = automaton::run::Occurrences::occurrences(automaton, input);
-			for(unsigned number : res ) {
-				std::cout << number << std::endl;
-			}
+			alib::DataFactory::toStdout( res );
 			return 0;
 		} else if( type.getValue() == "accept") {
 			string::LinearString input = alib::DataFactory::fromTokens<string::LinearString>(inputTokens);
 			automaton::Automaton automaton = alib::DataFactory::fromTokens<automaton::Automaton>(automatonTokens);
 			bool res = automaton::run::Accept::accept(automaton, input);
-			if(res) {
-				std::cout << "Input matches." << std::endl;
-				return 0;
-			} else {
-				std::cout << "Input don't matches." << std::endl;
-				return 1;
-			}
+			alib::DataFactory::toStdout( res );
 		} else {
 			throw exception::AlibException( "Invalid run type" );
 			return 1;

astringology2/src/astringology.cpp

@@ -50,9 +50,7 @@ int main(int argc, char* argv[]) {
 			string::String subject = alib::DataFactory::fromTokens<string::String>(subjectTokens);
 			string::String pattern = alib::DataFactory::fromTokens<string::String>(patternTokens);
 			std::set<unsigned> res = string::naive::ExactMatch::match(subject, pattern);
-			for(unsigned number : res ) {
-				std::cout << number << std::endl;
-			}
+			alib::DataFactory::toStdout(res);
 			return 0;
 		} else if( algorithm.getValue() == "exactMatchingAutomaton") {
 			string::String pattern = alib::DataFactory::fromTokens<string::String>(patternTokens);