diff --git a/alib2data/src/XmlApi.cpp b/alib2data/src/XmlApi.cpp
index 41a741a47fd6437ca5c7c58b527ba158ee31d0f7..9996ca7307f5080771833b94aea820a66aa79a71 100644
--- a/alib2data/src/XmlApi.cpp
+++ b/alib2data/src/XmlApi.cpp
@@ -955,126 +955,6 @@ void xmlApi<primitive::Primitive>::compose(std::deque<sax::Token>& output, const
 	ToXMLComposers::primitiveComposer.compose(output, data);
 }
 
-primitive::String xmlApi<primitive::String>::parse(std::deque<sax::Token>::iterator& input) {
-	return FromXMLParsers::primitiveParser.parseString(input);
-}
-
-bool xmlApi<primitive::String>::first(const std::deque<sax::Token>::const_iterator& input) {
-	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_STRING);
-}
-
-void xmlApi<primitive::String>::compose(std::deque<sax::Token>& output, const primitive::String& data) {
-	ToXMLComposers::primitiveComposer.compose(output, data);
-}
-
-std::string xmlApi<std::string>::parse(std::deque<sax::Token>::iterator& input) {
-	return FromXMLParsers::primitiveParser.parseStringRaw(input);
-}
-
-bool xmlApi<std::string>::first(const std::deque<sax::Token>::const_iterator& input) {
-	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_STRING);
-}
-
-void xmlApi<std::string>::compose(std::deque<sax::Token>& output, const std::string& data) {
-	ToXMLComposers::primitiveComposer.compose(output, data);
-}
-
-primitive::Integer xmlApi<primitive::Integer>::parse(std::deque<sax::Token>::iterator& input) {
-	return FromXMLParsers::primitiveParser.parseInteger(input);
-}
-
-bool xmlApi<primitive::Integer>::first(const std::deque<sax::Token>::const_iterator& input) {
-	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_INTEGER);
-}
-
-void xmlApi<primitive::Integer>::compose(std::deque<sax::Token>& output, const primitive::Integer& data) {
-	ToXMLComposers::primitiveComposer.compose(output, data);
-}
-
-int xmlApi<int>::parse(std::deque<sax::Token>::iterator& input) {
-	return FromXMLParsers::primitiveParser.parseIntegerRaw(input);
-}
-
-bool xmlApi<int>::first(const std::deque<sax::Token>::const_iterator& input) {
-	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_INTEGER);
-}
-
-void xmlApi<int>::compose(std::deque<sax::Token>& output, int data) {
-	ToXMLComposers::primitiveComposer.compose(output, data);
-}
-
-primitive::Character xmlApi<primitive::Character>::parse(std::deque<sax::Token>::iterator& input) {
-	return FromXMLParsers::primitiveParser.parseCharacter(input);
-}
-
-bool xmlApi<primitive::Character>::first(const std::deque<sax::Token>::const_iterator& input) {
-	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_CHARACTER);
-}
-
-void xmlApi<primitive::Character>::compose(std::deque<sax::Token>& output, const primitive::Character& data) {
-	ToXMLComposers::primitiveComposer.compose(output, data);
-}
-
-primitive::Unsigned xmlApi<primitive::Unsigned>::parse(std::deque<sax::Token>::iterator& input) {
-	return FromXMLParsers::primitiveParser.parseUnsigned(input);
-}
-
-bool xmlApi<primitive::Unsigned>::first(const std::deque<sax::Token>::const_iterator& input) {
-	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_UNSIGNED);
-}
-
-void xmlApi<primitive::Unsigned>::compose(std::deque<sax::Token>& output, const primitive::Unsigned& data) {
-	ToXMLComposers::primitiveComposer.compose(output, data);
-}
-
-primitive::Bool xmlApi<primitive::Bool>::parse(std::deque<sax::Token>::iterator& input) {
-	return FromXMLParsers::primitiveParser.parseBool(input);
-}
-
-bool xmlApi<primitive::Bool>::first(const std::deque<sax::Token>::const_iterator& input) {
-	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_BOOL);
-}
-
-void xmlApi<primitive::Bool>::compose(std::deque<sax::Token>& output, const primitive::Bool& data) {
-	ToXMLComposers::primitiveComposer.compose(output, data);
-}
-
-char xmlApi<char>::parse(std::deque<sax::Token>::iterator& input) {
-	return FromXMLParsers::primitiveParser.parseCharacterRaw(input);
-}
-
-bool xmlApi<char>::first(const std::deque<sax::Token>::const_iterator& input) {
-	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_CHARACTER);
-}
-
-void xmlApi<char>::compose(std::deque<sax::Token>& output, char data) {
-	ToXMLComposers::primitiveComposer.compose(output, data);
-}
-
-unsigned xmlApi<unsigned>::parse(std::deque<sax::Token>::iterator& input) {
-	return FromXMLParsers::primitiveParser.parseCharacterRaw(input);
-}
-
-bool xmlApi<unsigned>::first(const std::deque<sax::Token>::const_iterator& input) {
-	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_CHARACTER);
-}
-
-void xmlApi<unsigned>::compose(std::deque<sax::Token>& output, unsigned data) {
-	ToXMLComposers::primitiveComposer.compose(output, data);
-}
-
-bool xmlApi<bool>::parse(std::deque<sax::Token>::iterator& input) {
-	return FromXMLParsers::primitiveParser.parseCharacterRaw(input);
-}
-
-bool xmlApi<bool>::first(const std::deque<sax::Token>::const_iterator& input) {
-	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_CHARACTER);
-}
-
-void xmlApi<bool>::compose(std::deque<sax::Token>& output, bool data) {
-	ToXMLComposers::primitiveComposer.compose(output, data);
-}
-
 tree::Tree xmlApi<tree::Tree>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::treeParser.parseTree(input);
 }
diff --git a/alib2data/src/XmlApi.hpp b/alib2data/src/XmlApi.hpp
index 59ae0853a6506c131fd19d2d17060af6a4cf684c..d5b69683eda4cb0cd45601261973802a4c8c7f0a 100644
--- a/alib2data/src/XmlApi.hpp
+++ b/alib2data/src/XmlApi.hpp
@@ -40,13 +40,6 @@
 
 namespace alib {
 
-template<typename T>
-struct xmlApi {
-	static T parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, const T& data);
-};
-
 template<>
 struct xmlApi<Void> {
 	static Void parse(std::deque<sax::Token>::iterator& input);
@@ -607,76 +600,6 @@ struct xmlApi<primitive::Primitive> {
 	static void compose(std::deque<sax::Token>& output, const primitive::Primitive& data);
 };
 
-template<>
-struct xmlApi<primitive::String> {
-	static primitive::String parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, const primitive::String& data);
-};
-
-template<>
-struct xmlApi<std::string> {
-	static std::string parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, const std::string& data);
-};
-
-template<>
-struct xmlApi<primitive::Integer> {
-	static primitive::Integer parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, const primitive::Integer& data);
-};
-
-template<>
-struct xmlApi<int> {
-	static int parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, int data);
-};
-
-template<>
-struct xmlApi<primitive::Character> {
-	static primitive::Character parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, const primitive::Character& data);
-};
-
-template<>
-struct xmlApi<char> {
-	static char parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, char data);
-};
-
-template<>
-struct xmlApi<primitive::Unsigned> {
-	static primitive::Unsigned parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, const primitive::Unsigned& data);
-};
-
-template<>
-struct xmlApi<unsigned> {
-	static unsigned parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, unsigned data);
-};
-
-template<>
-struct xmlApi<primitive::Bool> {
-	static primitive::Bool parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, const primitive::Bool& data);
-};
-
-template<>
-struct xmlApi<bool> {
-	static bool parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, bool data);
-};
-
 template<>
 struct xmlApi<tree::Tree> {
 	static tree::Tree parse(std::deque<sax::Token>::iterator& input);
diff --git a/alib2data/src/XmlApiBase.h b/alib2data/src/XmlApiBase.h
new file mode 100644
index 0000000000000000000000000000000000000000..5681a517f00bbaa5a726d1e50198492af48737b5
--- /dev/null
+++ b/alib2data/src/XmlApiBase.h
@@ -0,0 +1,25 @@
+/*
+ * XmlApiBase.hpp
+ *
+ * Created on: Apr 1, 2013
+ * Author: Jan Travnicek
+ */
+
+#ifndef XML_API_BASE_H_
+#define XML_API_BASE_H_
+
+#include <deque>
+#include "sax/Token.h"
+
+namespace alib {
+
+template<typename T>
+struct xmlApi {
+	static T parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
+	static void compose(std::deque<sax::Token>& output, const T& data);
+};
+
+} /* namespace alib */
+
+#endif /* XML_API_BASE_H_ */
diff --git a/alib2data/src/XmlTagNames.cpp b/alib2data/src/XmlTagNames.cpp
index 993ab14a1eb83e56e5b0ef5aeba2b9924090d79f..5a5e55e8582b966bca1bfcdc69e91ebe9fa3011a 100644
--- a/alib2data/src/XmlTagNames.cpp
+++ b/alib2data/src/XmlTagNames.cpp
@@ -73,11 +73,6 @@ 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_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";
 const std::string Names::TREE_RANKED_TREE = "RankedTree";
 const std::string Names::TREE_RANKED_PATTERN = "RankedPattern";
 const std::string Names::TREE_PREFIX_RANKED_TREE = "PrefixRankedTree";
diff --git a/alib2data/src/XmlTagNames.h b/alib2data/src/XmlTagNames.h
index ead673150acc8402c5b63b66c70d49495d4ce508..4cdcb8e8cf690e6c28d1b7962bc0bac78a868f6c 100644
--- a/alib2data/src/XmlTagNames.h
+++ b/alib2data/src/XmlTagNames.h
@@ -78,11 +78,6 @@ struct Names {
 	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_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;
 	const static std::string TREE_RANKED_TREE;
 	const static std::string TREE_RANKED_PATTERN;
 	const static std::string TREE_PREFIX_RANKED_TREE;
diff --git a/alib2data/src/primitive/Bool.cpp b/alib2data/src/primitive/Bool.cpp
index 6f13273063a7dea6e661ca08bdafab54efc19560..66f5b97ff464156386a6cf763d3b2d14fb263a90 100644
--- a/alib2data/src/primitive/Bool.cpp
+++ b/alib2data/src/primitive/Bool.cpp
@@ -6,6 +6,8 @@
  */
 
 #include "Bool.h"
+#include "../sax/FromXMLParserHelper.h"
+#include "../exception/AlibException.h"
 
 namespace primitive {
 
@@ -41,5 +43,65 @@ Bool::operator std::string() const {
 	return data ? "true" : "false";
 }
 
+const std::string Bool::PRIMITIVE_BOOL = "Bool";
+
+Bool Bool::parseBool(std::deque<sax::Token>::iterator& input) {
+	return Bool(parseBoolRaw(input));
+}
+
+bool Bool::parseBoolRaw(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, Bool::PRIMITIVE_BOOL);
+	std::string tmp = sax::FromXMLParserHelper::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");
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, Bool::PRIMITIVE_BOOL);
+	return data;
+}
+
+void Bool::compose(std::deque<sax::Token>& out) const {
+	compose(out, getData());
+}
+
+void Bool::compose(std::deque<sax::Token>& out, bool primitive) {
+	out.emplace_back(Bool::PRIMITIVE_BOOL, sax::Token::TokenType::START_ELEMENT);
+	if(primitive)
+		out.emplace_back("true", sax::Token::TokenType::CHARACTER);
+	else
+		out.emplace_back("false", sax::Token::TokenType::CHARACTER);
+	out.emplace_back(Bool::PRIMITIVE_BOOL, sax::Token::TokenType::END_ELEMENT);
+}
+
 } /* namespace primitive */
 
+namespace alib {
+
+primitive::Bool xmlApi<primitive::Bool>::parse(std::deque<sax::Token>::iterator& input) {
+	return primitive::Bool::parseBool(input);
+}
+
+bool xmlApi<primitive::Bool>::first(const std::deque<sax::Token>::const_iterator& input) {
+	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, primitive::Bool::PRIMITIVE_BOOL);
+}
+
+void xmlApi<primitive::Bool>::compose(std::deque<sax::Token>& output, const primitive::Bool& data) {
+	data.compose(output);
+}
+
+bool xmlApi<bool>::parse(std::deque<sax::Token>::iterator& input) {
+	return primitive::Bool::parseBoolRaw(input);
+}
+
+bool xmlApi<bool>::first(const std::deque<sax::Token>::const_iterator& input) {
+	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, primitive::Bool::PRIMITIVE_BOOL);
+}
+
+void xmlApi<bool>::compose(std::deque<sax::Token>& output, bool data) {
+	primitive::Bool::compose(output, data);
+}
+
+} /* namespace alib */
diff --git a/alib2data/src/primitive/Bool.h b/alib2data/src/primitive/Bool.h
index cccdb8a1896fca3477fd9193a4944e2e4c094659..b29abd64d556a90d8b7e9939c21841d21ab81b77 100644
--- a/alib2data/src/primitive/Bool.h
+++ b/alib2data/src/primitive/Bool.h
@@ -9,6 +9,7 @@
 #define PRIMITIVE_BOOL_H_
 
 #include "PrimitiveBase.h"
+#include "../XmlApiBase.h"
 
 namespace primitive {
 
@@ -53,6 +54,14 @@ public:
 	virtual int selfTypeId() const {
 		return typeId(*this);
 	}
+
+	const static std::string PRIMITIVE_BOOL;
+
+	static Bool parseBool(std::deque<sax::Token>::iterator& input);
+	static bool parseBoolRaw(std::deque<sax::Token>::iterator& input);
+
+	void compose(std::deque<sax::Token>& out) const;
+	static void compose(std::deque<sax::Token>& out, bool primitive);
 };
 
 } /* namespace primitive */
@@ -68,4 +77,22 @@ struct compare<primitive::Bool> {
 
 } /* namespace std */
 
+namespace alib {
+
+template<>
+struct xmlApi<primitive::Bool> {
+	static primitive::Bool parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
+	static void compose(std::deque<sax::Token>& output, const primitive::Bool& data);
+};
+
+template<>
+struct xmlApi<bool> {
+	static bool parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
+	static void compose(std::deque<sax::Token>& output, bool data);
+};
+
+} /* namespace alib */
+
 #endif /* PRIMITIVE_BOOL_H_ */
diff --git a/alib2data/src/primitive/Character.cpp b/alib2data/src/primitive/Character.cpp
index 87d6678c56f33ca930af22a18c662363d3c6f9f2..d720d7f9cff8981befa3199410e3095118d84ff1 100644
--- a/alib2data/src/primitive/Character.cpp
+++ b/alib2data/src/primitive/Character.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "Character.h"
+#include "../sax/FromXMLParserHelper.h"
 
 namespace primitive {
 
@@ -41,5 +42,56 @@ Character::operator std::string() const {
 	return std::string(1, data);
 }
 
+const std::string Character::PRIMITIVE_CHARACTER = "Character";
+
+Character Character::parseCharacter(std::deque<sax::Token>::iterator& input) {
+	return Character(parseCharacterRaw(input));
+}
+
+char Character::parseCharacterRaw(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, Character::PRIMITIVE_CHARACTER);
+	char data = sax::FromXMLParserHelper::popTokenData(input, sax::Token::TokenType::CHARACTER)[0];
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, Character::PRIMITIVE_CHARACTER);
+	return data;
+}
+
+void Character::compose(std::deque<sax::Token>& out) const {
+	compose(out, this->getData());
+}
+
+void Character::compose(std::deque<sax::Token>& out, char primitive) {
+	out.emplace_back(Character::PRIMITIVE_CHARACTER, sax::Token::TokenType::START_ELEMENT);
+	out.emplace_back(std::string(1, primitive), sax::Token::TokenType::CHARACTER);
+	out.emplace_back(Character::PRIMITIVE_CHARACTER, sax::Token::TokenType::END_ELEMENT);
+}
+
 } /* namespace primitive */
 
+namespace alib {
+
+primitive::Character xmlApi<primitive::Character>::parse(std::deque<sax::Token>::iterator& input) {
+	return primitive::Character::parseCharacter(input);
+}
+
+bool xmlApi<primitive::Character>::first(const std::deque<sax::Token>::const_iterator& input) {
+	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, primitive::Character::PRIMITIVE_CHARACTER);
+}
+
+void xmlApi<primitive::Character>::compose(std::deque<sax::Token>& output, const primitive::Character& data) {
+	data.compose(output);
+}
+
+char xmlApi<char>::parse(std::deque<sax::Token>::iterator& input) {
+	return primitive::Character::parseCharacterRaw(input);
+}
+
+bool xmlApi<char>::first(const std::deque<sax::Token>::const_iterator& input) {
+	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, primitive::Character::PRIMITIVE_CHARACTER);
+}
+
+void xmlApi<char>::compose(std::deque<sax::Token>& output, char data) {
+	primitive::Character::compose(output, data);
+}
+
+} /* namespace alib */
+
diff --git a/alib2data/src/primitive/Character.h b/alib2data/src/primitive/Character.h
index ac1be6ab30802a407ec00a81e279eae493b06987..4d16ba6f2fef1c63b08e1d739402b0c7b540791d 100644
--- a/alib2data/src/primitive/Character.h
+++ b/alib2data/src/primitive/Character.h
@@ -9,6 +9,7 @@
 #define PRIMITIVE_CHARACTER_H_
 
 #include "PrimitiveBase.h"
+#include "../XmlApiBase.h"
 
 namespace primitive {
 
@@ -53,6 +54,14 @@ public:
 	virtual int selfTypeId() const {
 		return typeId(*this);
 	}
+
+	const static std::string PRIMITIVE_CHARACTER;
+
+	static Character parseCharacter(std::deque<sax::Token>::iterator& input);
+	static char parseCharacterRaw(std::deque<sax::Token>::iterator& input);
+
+	void compose(std::deque<sax::Token>& out) const;
+	static void compose(std::deque<sax::Token>& out, char primitive);
 };
 
 } /* namespace primitive */
@@ -68,5 +77,23 @@ struct compare<primitive::Character> {
 
 } /* namespace std */
 
+namespace alib {
+
+template<>
+struct xmlApi<primitive::Character> {
+	static primitive::Character parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
+	static void compose(std::deque<sax::Token>& output, const primitive::Character& data);
+};
+
+template<>
+struct xmlApi<char> {
+	static char parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
+	static void compose(std::deque<sax::Token>& output, char data);
+};
+
+} /* namespace alib */
+
 #endif /* PRIMITIVE_CHARACTER_H_ */
 
diff --git a/alib2data/src/primitive/Integer.cpp b/alib2data/src/primitive/Integer.cpp
index 8791603121f207ca071b506339f6c00dc1cb080a..45ca153c38b09c26a4bcb811e79058274916d76d 100644
--- a/alib2data/src/primitive/Integer.cpp
+++ b/alib2data/src/primitive/Integer.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "Integer.h"
+#include "../sax/FromXMLParserHelper.h"
 
 namespace primitive {
 
@@ -41,5 +42,56 @@ Integer::operator std::string() const {
 	return std::to_string(data);
 }
 
+const std::string Integer::PRIMITIVE_INTEGER = "Integer";
+
+Integer Integer::parseInteger(std::deque<sax::Token>::iterator& input) {
+	return Integer(parseIntegerRaw(input));
+}
+
+int Integer::parseIntegerRaw(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, Integer::PRIMITIVE_INTEGER);
+	int data = std::stoi(sax::FromXMLParserHelper::popTokenData(input, sax::Token::TokenType::CHARACTER));
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, Integer::PRIMITIVE_INTEGER);
+	return data;
+}
+
+void Integer::compose(std::deque<sax::Token>& out) const {
+	compose(out, this->getData());
+}
+
+void Integer::compose(std::deque<sax::Token>& out, int primitive) {
+	out.emplace_back(Integer::PRIMITIVE_INTEGER, sax::Token::TokenType::START_ELEMENT);
+	out.emplace_back(std::itos(primitive), sax::Token::TokenType::CHARACTER);
+	out.emplace_back(Integer::PRIMITIVE_INTEGER, sax::Token::TokenType::END_ELEMENT);
+}
+
 } /* namespace primitive */
 
+namespace alib {
+
+primitive::Integer xmlApi<primitive::Integer>::parse(std::deque<sax::Token>::iterator& input) {
+	return primitive::Integer::parseInteger(input);
+}
+
+bool xmlApi<primitive::Integer>::first(const std::deque<sax::Token>::const_iterator& input) {
+	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, primitive::Integer::PRIMITIVE_INTEGER);
+}
+
+void xmlApi<primitive::Integer>::compose(std::deque<sax::Token>& output, const primitive::Integer& data) {
+	data.compose(output);
+}
+
+int xmlApi<int>::parse(std::deque<sax::Token>::iterator& input) {
+	return primitive::Integer::parseIntegerRaw(input);
+}
+
+bool xmlApi<int>::first(const std::deque<sax::Token>::const_iterator& input) {
+	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, primitive::Integer::PRIMITIVE_INTEGER);
+}
+
+void xmlApi<int>::compose(std::deque<sax::Token>& output, int data) {
+	primitive::Integer::compose(output, data);
+}
+
+} /* namespace alib */
+
diff --git a/alib2data/src/primitive/Integer.h b/alib2data/src/primitive/Integer.h
index fa9c5e69fdb25b62c90190d25f7603e92b589d72..ac06ebbf4924bdca622bc0d50c35c2e4ccbab797 100644
--- a/alib2data/src/primitive/Integer.h
+++ b/alib2data/src/primitive/Integer.h
@@ -9,6 +9,7 @@
 #define PRIMITIVE_INTEGER_H_
 
 #include "PrimitiveBase.h"
+#include "../XmlApiBase.h"
 
 namespace primitive {
 
@@ -53,6 +54,14 @@ public:
 	virtual int selfTypeId() const {
 		return typeId(*this);
 	}
+
+	const static std::string PRIMITIVE_INTEGER;
+
+	static Integer parseInteger(std::deque<sax::Token>::iterator& input);
+	static int parseIntegerRaw(std::deque<sax::Token>::iterator& input);
+
+	void compose(std::deque<sax::Token>& out) const;
+	static void compose(std::deque<sax::Token>& out, int primitive);
 };
 
 } /* namespace primitive */
@@ -68,4 +77,22 @@ struct compare<primitive::Integer> {
 
 } /* namespace std */
 
+namespace alib{
+
+template<>
+struct xmlApi<primitive::Integer> {
+	static primitive::Integer parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
+	static void compose(std::deque<sax::Token>& output, const primitive::Integer& data);
+};
+
+template<>
+struct xmlApi<int> {
+	static int parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
+	static void compose(std::deque<sax::Token>& output, int data);
+};
+
+} /* namespace alib */
+
 #endif /* PRIMITIVE_INTEGER_H_ */
diff --git a/alib2data/src/primitive/PrimitiveFromXMLParser.cpp b/alib2data/src/primitive/PrimitiveFromXMLParser.cpp
index 1cb253ad1da5eb6b4ff9bfc03f024d4ea05b7459..7709a983a7f951e6bfa64ffc00e960b6c0d3cb88 100644
--- a/alib2data/src/primitive/PrimitiveFromXMLParser.cpp
+++ b/alib2data/src/primitive/PrimitiveFromXMLParser.cpp
@@ -21,19 +21,19 @@ Primitive PrimitiveFromXMLParser::parsePrimitive(std::deque<sax::Token>::iterato
 Primitive PrimitiveFromXMLParser::parsePrimitive(std::deque<sax::Token>::iterator& input, const std::set<FEATURES>& features) const {
 	if(alib::xmlApi<Integer>::first(input)) {
 		if(!features.count(FEATURES::INTEGER)) throw exception::AlibException();
-		return Primitive(parseInteger(input));
+		return Primitive(Integer::parseInteger(input));
 	} else if(alib::xmlApi<String>::first(input)) {
 		if(!features.count(FEATURES::STRING)) throw exception::AlibException();
-		return Primitive(parseString(input));
+		return Primitive(String::parseString(input));
 	} else if(alib::xmlApi<Character>::first(input)) {
 		if(!features.count(FEATURES::CHAR)) throw exception::AlibException();
-		return Primitive(parseCharacter(input));
+		return Primitive(Character::parseCharacter(input));
 	} else if(alib::xmlApi<Unsigned>::first(input)) {
 		if(!features.count(FEATURES::UNSIGNED)) throw exception::AlibException();
-		return Primitive(parseUnsigned(input));
+		return Primitive(Unsigned::parseUnsigned(input));
 	} else if(alib::xmlApi<Bool>::first(input)) {
 		if(!features.count(FEATURES::BOOL)) throw exception::AlibException();
-		return Primitive(parseBool(input));
+		return Primitive(Bool::parseBool(input));
 	} else {
 		throw sax::ParserException(sax::Token("Integer, String, Character, Unsigned, Bool", sax::Token::TokenType::START_ELEMENT), *input);
 	}
@@ -47,90 +47,4 @@ bool PrimitiveFromXMLParser::first(const std::deque<sax::Token>::const_iterator&
 	}
 }
 
-Integer PrimitiveFromXMLParser::parseInteger(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::PRIMITIVE_INTEGER);
-	Integer data(std::stoi(popTokenData(input, sax::Token::TokenType::CHARACTER)));
-	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::PRIMITIVE_INTEGER);
-	return data;
-}
-
-Character PrimitiveFromXMLParser::parseCharacter(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::PRIMITIVE_CHARACTER);
-	Character data(popTokenData(input, sax::Token::TokenType::CHARACTER)[0]);
-	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::PRIMITIVE_CHARACTER);
-	return data;
-}
-
-String PrimitiveFromXMLParser::parseString(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::PRIMITIVE_STRING);
-	std::string data = "";
-	if( isTokenType(input, sax::Token::TokenType::CHARACTER))
-		data = popTokenData(input, sax::Token::TokenType::CHARACTER);
-	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::PRIMITIVE_STRING);
-	return String(std::move(data));
-}
-
-Unsigned PrimitiveFromXMLParser::parseUnsigned(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::PRIMITIVE_UNSIGNED);
-	Unsigned data(std::stou(popTokenData(input, sax::Token::TokenType::CHARACTER)));
-	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::PRIMITIVE_UNSIGNED);
-	return data;
-}
-
-Bool PrimitiveFromXMLParser::parseBool(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::PRIMITIVE_BOOL);
-	std::string tmp = popTokenData(input, sax::Token::TokenType::CHARACTER);
-	bool data;
-	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, alib::Names::PRIMITIVE_BOOL);
-	return Bool(data);
-}
-
-int PrimitiveFromXMLParser::parseIntegerRaw(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::PRIMITIVE_INTEGER);
-	int data = std::stoi(popTokenData(input, sax::Token::TokenType::CHARACTER));
-	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::PRIMITIVE_INTEGER);
-	return data;
-}
-
-char PrimitiveFromXMLParser::parseCharacterRaw(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::PRIMITIVE_CHARACTER);
-	char data = popTokenData(input, sax::Token::TokenType::CHARACTER)[0];
-	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::PRIMITIVE_CHARACTER);
-	return data;
-}
-
-std::string PrimitiveFromXMLParser::parseStringRaw(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::PRIMITIVE_STRING);
-	std::string data = popTokenData(input, sax::Token::TokenType::CHARACTER);
-	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::PRIMITIVE_STRING);
-	return data;
-}
-
-unsigned PrimitiveFromXMLParser::parseUnsignedRaw(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::PRIMITIVE_UNSIGNED);
-	unsigned data = std::stou(popTokenData(input, sax::Token::TokenType::CHARACTER));
-	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::PRIMITIVE_UNSIGNED);
-	return data;
-}
-
-bool PrimitiveFromXMLParser::parseBoolRaw(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::PRIMITIVE_BOOL);
-	std::string tmp = popTokenData(input, sax::Token::TokenType::CHARACTER);
-	bool data;
-	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, alib::Names::PRIMITIVE_BOOL);
-	return data;
-}
-
 } /* namespace primitive */
diff --git a/alib2data/src/primitive/PrimitiveFromXMLParser.h b/alib2data/src/primitive/PrimitiveFromXMLParser.h
index c42975ff99121a1451d8342c1839872072832a2d..6443b29b0ad7fd9aaf98067f0447e7bde02ee874 100644
--- a/alib2data/src/primitive/PrimitiveFromXMLParser.h
+++ b/alib2data/src/primitive/PrimitiveFromXMLParser.h
@@ -32,18 +32,6 @@ private:
 	Primitive parsePrimitive(std::deque<sax::Token>::iterator& input, const std::set<FEATURES>&) const;
 	Primitive parsePrimitive(std::deque<sax::Token>::iterator& input) const;
 
-	Integer parseInteger(std::deque<sax::Token>::iterator& input) const;
-	Character parseCharacter(std::deque<sax::Token>::iterator& input) const;
-	String parseString(std::deque<sax::Token>::iterator& input) const;
-	Unsigned parseUnsigned(std::deque<sax::Token>::iterator& input) const;
-	Bool parseBool(std::deque<sax::Token>::iterator& input) const;
-
-	int parseIntegerRaw(std::deque<sax::Token>::iterator& input) const;
-	char parseCharacterRaw(std::deque<sax::Token>::iterator& input) const;
-	std::string parseStringRaw(std::deque<sax::Token>::iterator& input) const;
-	unsigned parseUnsignedRaw(std::deque<sax::Token>::iterator& input) const;
-	bool parseBoolRaw(std::deque<sax::Token>::iterator& input) const;
-
 	template<typename T> friend struct alib::xmlApi;
 public:
 	bool first(const std::deque<sax::Token>::const_iterator& input) const;
diff --git a/alib2data/src/primitive/PrimitiveToXMLComposer.cpp b/alib2data/src/primitive/PrimitiveToXMLComposer.cpp
index 4be1fdfe7295e6a5845bf2d023bb2fe370a21892..a5c97057cc4f02feb6c778dd3d3a270ee8e01509 100644
--- a/alib2data/src/primitive/PrimitiveToXMLComposer.cpp
+++ b/alib2data/src/primitive/PrimitiveToXMLComposer.cpp
@@ -22,70 +22,4 @@ void PrimitiveToXMLComposer::compose(std::deque<sax::Token>& out, const Primitiv
 	primitive.Accept((void*) &out, alib::ToXMLComposers::toXMLComposers);
 }
 
-void PrimitiveToXMLComposer::compose(std::deque<sax::Token>& out, const Integer& primitive) const {
-	out.emplace_back(alib::Names::PRIMITIVE_INTEGER, sax::Token::TokenType::START_ELEMENT);
-	out.emplace_back(std::itos(primitive.getData()), sax::Token::TokenType::CHARACTER);
-	out.emplace_back(alib::Names::PRIMITIVE_INTEGER, sax::Token::TokenType::END_ELEMENT);
-}
-
-void PrimitiveToXMLComposer::compose(std::deque<sax::Token>& out, const Character& primitive) const {
-	out.emplace_back(alib::Names::PRIMITIVE_CHARACTER, sax::Token::TokenType::START_ELEMENT);
-	out.emplace_back(std::string(1, primitive.getData()), sax::Token::TokenType::CHARACTER);
-	out.emplace_back(alib::Names::PRIMITIVE_CHARACTER, sax::Token::TokenType::END_ELEMENT);
-}
-
-void PrimitiveToXMLComposer::compose(std::deque<sax::Token>& out, const Unsigned& primitive) const {
-	out.emplace_back(alib::Names::PRIMITIVE_UNSIGNED, sax::Token::TokenType::START_ELEMENT);
-	out.emplace_back(std::utos(primitive.getData()), sax::Token::TokenType::CHARACTER);
-	out.emplace_back(alib::Names::PRIMITIVE_UNSIGNED, sax::Token::TokenType::END_ELEMENT);
-}
-
-void PrimitiveToXMLComposer::compose(std::deque<sax::Token>& out, const Bool& primitive) const {
-	out.emplace_back(alib::Names::PRIMITIVE_BOOL, sax::Token::TokenType::START_ELEMENT);
-	if(primitive.getData())
-		out.emplace_back("true", sax::Token::TokenType::CHARACTER);
-	else
-		out.emplace_back("false", sax::Token::TokenType::CHARACTER);
-	out.emplace_back(alib::Names::PRIMITIVE_BOOL, sax::Token::TokenType::END_ELEMENT);
-}
-
-void PrimitiveToXMLComposer::compose(std::deque<sax::Token>& out, const String& primitive) const {
-	out.emplace_back(alib::Names::PRIMITIVE_STRING, sax::Token::TokenType::START_ELEMENT);
-	out.emplace_back(primitive.getData(), sax::Token::TokenType::CHARACTER);
-	out.emplace_back(alib::Names::PRIMITIVE_STRING, sax::Token::TokenType::END_ELEMENT);
-}
-
-void PrimitiveToXMLComposer::compose(std::deque<sax::Token>& out, int primitive) const {
-	out.emplace_back(alib::Names::PRIMITIVE_INTEGER, sax::Token::TokenType::START_ELEMENT);
-	out.emplace_back(std::itos(primitive), sax::Token::TokenType::CHARACTER);
-	out.emplace_back(alib::Names::PRIMITIVE_INTEGER, sax::Token::TokenType::END_ELEMENT);
-}
-
-void PrimitiveToXMLComposer::compose(std::deque<sax::Token>& out, char primitive) const {
-	out.emplace_back(alib::Names::PRIMITIVE_CHARACTER, sax::Token::TokenType::START_ELEMENT);
-	out.emplace_back(std::string(1, primitive), sax::Token::TokenType::CHARACTER);
-	out.emplace_back(alib::Names::PRIMITIVE_CHARACTER, sax::Token::TokenType::END_ELEMENT);
-}
-
-void PrimitiveToXMLComposer::compose(std::deque<sax::Token>& out, const std::string& primitive) const {
-	out.emplace_back(alib::Names::PRIMITIVE_STRING, sax::Token::TokenType::START_ELEMENT);
-	out.emplace_back(primitive, sax::Token::TokenType::CHARACTER);
-	out.emplace_back(alib::Names::PRIMITIVE_STRING, sax::Token::TokenType::END_ELEMENT);
-}
-
-void PrimitiveToXMLComposer::compose(std::deque<sax::Token>& out, unsigned primitive) const {
-	out.emplace_back(alib::Names::PRIMITIVE_UNSIGNED, sax::Token::TokenType::START_ELEMENT);
-	out.emplace_back(std::utos(primitive), sax::Token::TokenType::CHARACTER);
-	out.emplace_back(alib::Names::PRIMITIVE_UNSIGNED, sax::Token::TokenType::END_ELEMENT);
-}
-
-void PrimitiveToXMLComposer::compose(std::deque<sax::Token>& out, bool primitive) const {
-	out.emplace_back(alib::Names::PRIMITIVE_BOOL, sax::Token::TokenType::START_ELEMENT);
-	if(primitive)
-		out.emplace_back("true", sax::Token::TokenType::CHARACTER);
-	else
-		out.emplace_back("false", sax::Token::TokenType::CHARACTER);
-	out.emplace_back(alib::Names::PRIMITIVE_BOOL, sax::Token::TokenType::END_ELEMENT);
-}
-
 } /* namespace primitive */
diff --git a/alib2data/src/primitive/PrimitiveToXMLComposer.h b/alib2data/src/primitive/PrimitiveToXMLComposer.h
index 328c533fe63a3aeef59f07aa2349dd1bf62e9135..e4d401dd2d6aa07b55873e9fec96c18c2c20b058 100644
--- a/alib2data/src/primitive/PrimitiveToXMLComposer.h
+++ b/alib2data/src/primitive/PrimitiveToXMLComposer.h
@@ -43,18 +43,6 @@ private:
 	 */
 	void compose(std::deque<sax::Token>& out, const Primitive& primitive) const;
 
-	void compose(std::deque<sax::Token>& out, const String& primitive) const;
-	void compose(std::deque<sax::Token>& out, const Integer& primitive) const;
-	void compose(std::deque<sax::Token>& out, const Character& primitive) const;
-	void compose(std::deque<sax::Token>& out, const Unsigned& primitive) const;
-	void compose(std::deque<sax::Token>& out, const Bool& primitive) const;
-
-	void compose(std::deque<sax::Token>& out, const std::string& primitive) const;
-	void compose(std::deque<sax::Token>& out, int primitive) const;
-	void compose(std::deque<sax::Token>& out, char primitive) const;
-	void compose(std::deque<sax::Token>& out, unsigned primitive) const;
-	void compose(std::deque<sax::Token>& out, bool primitive) const;
-
 	template<typename T> friend struct alib::xmlApi;
 };
 
diff --git a/alib2data/src/primitive/String.cpp b/alib2data/src/primitive/String.cpp
index fcae527dc9d73e5657878ca4a194828246db4fd1..6d5213248e02f2a4c477c9d896c5555524b3531a 100644
--- a/alib2data/src/primitive/String.cpp
+++ b/alib2data/src/primitive/String.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "String.h"
+#include "../sax/FromXMLParserHelper.h"
 
 namespace primitive {
 
@@ -45,5 +46,59 @@ String::operator std::string() const {
 	return data;
 }
 
+const std::string String::PRIMITIVE_STRING = "String";
+
+String String::parseString(std::deque<sax::Token>::iterator& input) {
+	return String(parseStringRaw(input));
+}
+
+std::string String::parseStringRaw(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, primitive::String::PRIMITIVE_STRING);
+	std::string data = "";
+	if( sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::CHARACTER))
+		data = sax::FromXMLParserHelper::popTokenData(input, sax::Token::TokenType::CHARACTER);
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, primitive::String::PRIMITIVE_STRING);
+	return data;
+}
+
+
+void String::compose(std::deque<sax::Token>& out) const {
+	compose(out, this->getData());
+}
+
+void String::compose(std::deque<sax::Token>& out, std::string primitive) {
+	out.emplace_back(primitive::String::PRIMITIVE_STRING, sax::Token::TokenType::START_ELEMENT);
+	out.emplace_back(primitive, sax::Token::TokenType::CHARACTER);
+	out.emplace_back(primitive::String::PRIMITIVE_STRING, sax::Token::TokenType::END_ELEMENT);
+}
+
 } /* namespace primitive */
 
+namespace alib {
+
+primitive::String xmlApi<primitive::String>::parse(std::deque<sax::Token>::iterator& input) {
+	return primitive::String::parseString(input);
+}
+
+bool xmlApi<primitive::String>::first(const std::deque<sax::Token>::const_iterator& input) {
+	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, primitive::String::PRIMITIVE_STRING);
+}
+
+void xmlApi<primitive::String>::compose(std::deque<sax::Token>& output, const primitive::String& data) {
+	data.compose(output);
+}
+
+std::string xmlApi<std::string>::parse(std::deque<sax::Token>::iterator& input) {
+	return primitive::String::parseStringRaw(input);
+}
+
+bool xmlApi<std::string>::first(const std::deque<sax::Token>::const_iterator& input) {
+	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, primitive::String::PRIMITIVE_STRING);
+}
+
+void xmlApi<std::string>::compose(std::deque<sax::Token>& output, std::string data) {
+	primitive::String::compose(output, data);
+}
+
+} /* namespace alib */
+
diff --git a/alib2data/src/primitive/String.h b/alib2data/src/primitive/String.h
index 7cbf3f433ccd1b660941c1228c25a4537c91585d..5c0f6432db4b6812bf6a406682fa05e612c6afef 100644
--- a/alib2data/src/primitive/String.h
+++ b/alib2data/src/primitive/String.h
@@ -10,6 +10,7 @@
 
 #include <string>
 #include "PrimitiveBase.h"
+#include "../XmlApiBase.h"
 
 namespace primitive {
 
@@ -56,6 +57,14 @@ public:
 	virtual int selfTypeId() const {
 		return typeId(*this);
 	}
+
+	const static std::string PRIMITIVE_STRING;
+
+	static String parseString(std::deque<sax::Token>::iterator& input);
+	static std::string parseStringRaw(std::deque<sax::Token>::iterator& input);
+
+	void compose(std::deque<sax::Token>& out) const;
+	static void compose(std::deque<sax::Token>& out, std::string primitive);
 };
 
 } /* namespace primitive */
@@ -71,5 +80,23 @@ struct compare<primitive::String> {
 
 } /* namespace std */
 
+namespace alib{
+
+template<>
+struct xmlApi<primitive::String> {
+	static primitive::String parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
+	static void compose(std::deque<sax::Token>& output, const primitive::String& data);
+};
+
+template<>
+struct xmlApi<std::string> {
+	static std::string parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
+	static void compose(std::deque<sax::Token>& output, std::string data);
+};
+
+} /* namespace alib */
+
 #endif /* PRIMITIVE_STRING_H_ */
 
diff --git a/alib2data/src/primitive/Unsigned.cpp b/alib2data/src/primitive/Unsigned.cpp
index fc137715d5dd8a6155c36d1f617bd1063e2c8d53..33c8ba7561c33be8dc5fae9364ddc1629ffb755c 100644
--- a/alib2data/src/primitive/Unsigned.cpp
+++ b/alib2data/src/primitive/Unsigned.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "Unsigned.h"
+#include "../sax/FromXMLParserHelper.h"
 
 namespace primitive {
 
@@ -41,5 +42,56 @@ Unsigned::operator std::string() const {
 	return std::to_string(data);
 }
 
+const std::string Unsigned::PRIMITIVE_UNSIGNED = "Unsigned";
+
+Unsigned Unsigned::parseUnsigned(std::deque<sax::Token>::iterator& input) {
+	return Unsigned(parseUnsignedRaw(input));
+}
+
+unsigned Unsigned::parseUnsignedRaw(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, Unsigned::PRIMITIVE_UNSIGNED);
+	unsigned data = std::stoi(sax::FromXMLParserHelper::popTokenData(input, sax::Token::TokenType::CHARACTER));
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, Unsigned::PRIMITIVE_UNSIGNED);
+	return data;
+}
+
+void Unsigned::compose(std::deque<sax::Token>& out) const {
+	compose(out, this->getData());
+}
+
+void Unsigned::compose(std::deque<sax::Token>& out, unsigned primitive) {
+	out.emplace_back(Unsigned::PRIMITIVE_UNSIGNED, sax::Token::TokenType::START_ELEMENT);
+	out.emplace_back(std::itos(primitive), sax::Token::TokenType::CHARACTER);
+	out.emplace_back(Unsigned::PRIMITIVE_UNSIGNED, sax::Token::TokenType::END_ELEMENT);
+}
+
 } /* namespace primitive */
 
+namespace alib {
+
+primitive::Unsigned xmlApi<primitive::Unsigned>::parse(std::deque<sax::Token>::iterator& input) {
+	return primitive::Unsigned::parseUnsigned(input);
+}
+
+bool xmlApi<primitive::Unsigned>::first(const std::deque<sax::Token>::const_iterator& input) {
+	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, primitive::Unsigned::PRIMITIVE_UNSIGNED);
+}
+
+void xmlApi<primitive::Unsigned>::compose(std::deque<sax::Token>& output, const primitive::Unsigned& data) {
+	data.compose(output);
+}
+
+unsigned xmlApi<unsigned>::parse(std::deque<sax::Token>::iterator& input) {
+	return primitive::Unsigned::parseUnsignedRaw(input);
+}
+
+bool xmlApi<unsigned>::first(const std::deque<sax::Token>::const_iterator& input) {
+	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, primitive::Unsigned::PRIMITIVE_UNSIGNED);
+}
+
+void xmlApi<unsigned>::compose(std::deque<sax::Token>& output, unsigned data) {
+	primitive::Unsigned::compose(output, data);
+}
+
+} /* namespace alib */
+
diff --git a/alib2data/src/primitive/Unsigned.h b/alib2data/src/primitive/Unsigned.h
index e7369ef6b214d48d9bc190d77fa490cdf36050fe..eeca52b119a257406cf8fd7d5fa641541262e752 100644
--- a/alib2data/src/primitive/Unsigned.h
+++ b/alib2data/src/primitive/Unsigned.h
@@ -9,6 +9,7 @@
 #define PRIMITIVE_UNSIGNED_H_
 
 #include "PrimitiveBase.h"
+#include "../XmlApiBase.h"
 
 namespace primitive {
 
@@ -53,6 +54,14 @@ public:
 	virtual int selfTypeId() const {
 		return typeId(*this);
 	}
+
+	const static std::string PRIMITIVE_UNSIGNED;
+
+	static Unsigned parseUnsigned(std::deque<sax::Token>::iterator& input);
+	static unsigned parseUnsignedRaw(std::deque<sax::Token>::iterator& input);
+
+	void compose(std::deque<sax::Token>& out) const;
+	static void compose(std::deque<sax::Token>& out, unsigned primitive);
 };
 
 } /* namespace primitive */
@@ -68,4 +77,22 @@ struct compare<primitive::Unsigned> {
 
 } /* namespace std */
 
+namespace alib{
+
+template<>
+struct xmlApi<primitive::Unsigned> {
+	static primitive::Unsigned parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
+	static void compose(std::deque<sax::Token>& output, const primitive::Unsigned& data);
+};
+
+template<>
+struct xmlApi<unsigned> {
+	static unsigned parse(std::deque<sax::Token>::iterator& input);
+	static bool first(const std::deque<sax::Token>::const_iterator& input);
+	static void compose(std::deque<sax::Token>& output, unsigned data);
+};
+
+} /* namespace alib */
+
 #endif /* PRIMITIVE_UNSIGNED_H_ */
diff --git a/arun2/src/arun.cpp b/arun2/src/arun.cpp
index 3271cf66ac55d76ed256559bfd67263b51f82cca..de4d8fd165bc02f3250d2a156ffa4374b050c461 100644
--- a/arun2/src/arun.cpp
+++ b/arun2/src/arun.cpp
@@ -11,6 +11,7 @@
 #include <factory/XmlDataFactory.hpp>
 #include <exception/AlibException.h>
 #include <string/String.h>
+#include <primitive/Bool.h>
 #include <object/Object.h>
 #include <tree/ranked/RankedTree.h>
 #include <automaton/Automaton.h>