diff --git a/alib2data/src/PrimitiveRegistrator.cpp b/alib2data/src/PrimitiveRegistrator.cpp
index daf566c8df2790641deae6d4372e24302c04ace4..61c5be8abea1a9f5a37e9118a615c3af5d7ab84f 100644
--- a/alib2data/src/PrimitiveRegistrator.cpp
+++ b/alib2data/src/PrimitiveRegistrator.cpp
@@ -37,8 +37,8 @@
 #include <alphabet/xml/RankedSymbol.h>
 #include <alphabet/xml/BottomOfTheStackSymbol.h>
 
-#include <string/LinearString.h>
-#include <string/Epsilon.h>
+#include <string/xml/LinearString.h>
+#include <string/xml/Epsilon.h>
 
 namespace {
 
diff --git a/alib2data/src/string/CyclicString.cpp b/alib2data/src/string/CyclicString.cpp
index 904bcaf1db8b1127cde4c9e9fd0242d3034981b3..e6fb06edec6a305873b44d9b09a11447c6aa5341 100644
--- a/alib2data/src/string/CyclicString.cpp
+++ b/alib2data/src/string/CyclicString.cpp
@@ -6,11 +6,8 @@
  */
 
 #include "CyclicString.h"
-#include <string/String.h>
-#include <object/Object.h>
 
 #include <registration/ValuePrinterRegistration.hpp>
-#include <registration/XmlRegistration.hpp>
 #include <registration/CastRegistration.hpp>
 
 namespace {
@@ -19,10 +16,4 @@ static auto CyclicStringFromEpsilon = registration::CastRegister < string::Cycli
 
 static auto valuePrinter = registration::ValuePrinterRegister < string::CyclicString < > > ( );
 
-static auto xmlWrite = registration::XmlWriterRegister < string::String, string::CyclicString < > > ( );
-static auto xmlWrite2 = registration::XmlWriterRegister < alib::Object, string::CyclicString < > > ( );
-
-static auto xmlReader = registration::XmlReaderRegister < string::String, string::CyclicString < > > ( );
-static auto xmlReaded2 = registration::XmlReaderRegister < alib::Object, string::CyclicString < > > ( );
-
 } /* namespace */
diff --git a/alib2data/src/string/CyclicString.h b/alib2data/src/string/CyclicString.h
index 78b2677d0654894f411442cb2d8aaaefba76a61d..1c30d9fa29e324b64dc57b25ad0957f4d5acb073 100644
--- a/alib2data/src/string/CyclicString.h
+++ b/alib2data/src/string/CyclicString.h
@@ -14,13 +14,10 @@
 #include <algorithm>
 
 #include <core/components.hpp>
-#include <sax/FromXMLParserHelper.h>
 #include <object/UniqueObject.h>
 
 #include "StringBase.h"
 #include "StringFeatures.h"
-#include "common/StringFromXMLParser.h"
-#include "common/StringToXMLComposer.h"
 #include <exception/CommonException.h>
 #include <alphabet/common/SymbolNormalize.h>
 
@@ -93,10 +90,6 @@ public:
 		return xmlTagName;
 	}
 
-	static CyclicString parse ( ext::deque < sax::Token >::iterator & input );
-
-	static void compose ( ext::deque < sax::Token > & out, const CyclicString & string );
-
 	virtual alib::ObjectBase * inc ( ) &&;
 
 	typedef CyclicString < > normalized_type;
@@ -198,23 +191,6 @@ CyclicString < SymbolType >::operator std::string () const {
 	return std::move(ss).str();
 }
 
-template < class SymbolType >
-CyclicString < SymbolType > CyclicString < SymbolType >::parse(ext::deque<sax::Token>::iterator& input) {
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, CyclicString < >::getXmlTagName());
-	ext::set<SymbolType> alphabet = StringFromXMLParser::parseAlphabet < SymbolType > (input);
-	ext::vector<SymbolType> content = StringFromXMLParser::parseContent < SymbolType > (input);
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, CyclicString < >::getXmlTagName());
-	return CyclicString < SymbolType > ( std::move ( alphabet ), std::move ( content ) );
-}
-
-template < class SymbolType >
-void CyclicString < SymbolType >::compose(ext::deque<sax::Token>& out, const CyclicString & string ) {
-	out.emplace_back(CyclicString::getXmlTagName(), sax::Token::TokenType::START_ELEMENT);
-	StringToXMLComposer::compose(out, string.getAlphabet());
-	StringToXMLComposer::compose(out, string.m_Data);
-	out.emplace_back(CyclicString::getXmlTagName(), sax::Token::TokenType::END_ELEMENT);
-}
-
 template < class SymbolType >
 alib::ObjectBase* CyclicString < SymbolType >::inc() && {
 	return new alib::UniqueObject(alib::Object(std::move(*this)), primitive::Integer(0));
diff --git a/alib2data/src/string/Epsilon.cpp b/alib2data/src/string/Epsilon.cpp
index bf9d6e745eaffac53d0a9a64394fac5eb85588ba..275ce6af7f65423156ee0a383d8310fdc0bf1e13 100644
--- a/alib2data/src/string/Epsilon.cpp
+++ b/alib2data/src/string/Epsilon.cpp
@@ -7,21 +7,11 @@
 
 #include "Epsilon.h"
 
-#include <string/String.h>
-#include <object/Object.h>
-
 #include <registration/ValuePrinterRegistration.hpp>
-#include <registration/XmlRegistration.hpp>
 #include <registration/CastRegistration.hpp>
 
 namespace {
 
 static auto valuePrinter = registration::ValuePrinterRegister < string::Epsilon < > > ( );
 
-static auto xmlWrite = registration::XmlWriterRegister < string::String, string::Epsilon < > > ( );
-static auto xmlWrite2 = registration::XmlWriterRegister < alib::Object, string::Epsilon < > > ( );
-
-static auto xmlReader = registration::XmlReaderRegister < string::String, string::Epsilon < > > ( );
-static auto xmlReaded2 = registration::XmlReaderRegister < alib::Object, string::Epsilon < > > ( );
-
 } /* namespace */
diff --git a/alib2data/src/string/Epsilon.h b/alib2data/src/string/Epsilon.h
index 05d080a99b57135bf0c77572e2c769ac3af5358c..3947e1f3fdb9065de33ecde2ff26a48801ba992b 100644
--- a/alib2data/src/string/Epsilon.h
+++ b/alib2data/src/string/Epsilon.h
@@ -11,14 +11,11 @@
 #include <set>
 #include <vector>
 
-#include <sax/FromXMLParserHelper.h>
 #include <core/components.hpp>
 #include <object/UniqueObject.h>
 
 #include "StringBase.h"
 #include "StringFeatures.h"
-#include "common/StringFromXMLParser.h"
-#include "common/StringToXMLComposer.h"
 #include <alphabet/common/SymbolNormalize.h>
 
 #include <core/normalize.hpp>
@@ -85,10 +82,6 @@ public:
 		return xmlTagName;
 	}
 
-	static Epsilon parse ( ext::deque < sax::Token >::iterator & input );
-
-	static void compose ( ext::deque < sax::Token > & out, const Epsilon & epsilon );
-
 	virtual alib::ObjectBase * inc ( ) &&;
 
 	typedef Epsilon < > normalized_type;
@@ -144,21 +137,6 @@ Epsilon < SymbolType > Epsilon < SymbolType >::EPSILON = Epsilon < SymbolType >(
 template < class SymbolType >
 const ext::vector<SymbolType> Epsilon < SymbolType >::content;
 
-template < class SymbolType >
-Epsilon < SymbolType > Epsilon < SymbolType >::parse(ext::deque<sax::Token>::iterator& input) {
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, Epsilon::getXmlTagName());
-	ext::set<SymbolType> alphabet = StringFromXMLParser::parseAlphabet < SymbolType > (input);
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, Epsilon::getXmlTagName());
-	return Epsilon < SymbolType > (alphabet);
-}
-
-template < class SymbolType >
-void Epsilon < SymbolType >::compose(ext::deque<sax::Token>& out, const Epsilon & epsilon ) {
-	out.emplace_back(Epsilon::getXmlTagName(), sax::Token::TokenType::START_ELEMENT);
-	StringToXMLComposer::compose(out, epsilon.getAlphabet());
-	out.emplace_back(Epsilon::getXmlTagName(), sax::Token::TokenType::END_ELEMENT);
-}
-
 template < class SymbolType >
 alib::ObjectBase* Epsilon < SymbolType >::inc() && {
 	return new alib::UniqueObject(alib::Object(std::move(*this)), primitive::Integer(0));
diff --git a/alib2data/src/string/LinearString.cpp b/alib2data/src/string/LinearString.cpp
index 9ea07ef43562ce97843db30d8853de6f3991ee11..9951a60cf0282f2aa12ed93be70546376dda3318 100644
--- a/alib2data/src/string/LinearString.cpp
+++ b/alib2data/src/string/LinearString.cpp
@@ -7,11 +7,7 @@
 
 #include "LinearString.h"
 
-#include <string/String.h>
-#include <object/Object.h>
-
 #include <registration/ValuePrinterRegistration.hpp>
-#include <registration/XmlRegistration.hpp>
 #include <registration/CastRegistration.hpp>
 #include <registration/SetRegistration.hpp>
 #include <registration/ComponentRegistration.hpp>
@@ -39,10 +35,4 @@ static auto LinearStringSet = registration::SetRegister < string::LinearString <
 
 static auto valuePrinter = registration::ValuePrinterRegister < string::LinearString < > > ( );
 
-static auto xmlWrite = registration::XmlWriterRegister < string::String, string::LinearString < > > ( );
-static auto xmlWrite2 = registration::XmlWriterRegister < alib::Object, string::LinearString < > > ( );
-
-static auto xmlReader = registration::XmlReaderRegister < string::String, string::LinearString < > > ( );
-static auto xmlReaded2 = registration::XmlReaderRegister < alib::Object, string::LinearString < > > ( );
-
 } /* namespace */
diff --git a/alib2data/src/string/LinearString.h b/alib2data/src/string/LinearString.h
index 6c37e603d787c2aedb4b419b601627cfba708679..21d48e7d1f9733e119a21db17b1a8766e35562b4 100644
--- a/alib2data/src/string/LinearString.h
+++ b/alib2data/src/string/LinearString.h
@@ -13,18 +13,15 @@
 #include <sstream>
 #include <algorithm>
 
-#include <sax/FromXMLParserHelper.h>
 #include <core/components.hpp>
 #include <object/UniqueObject.h>
 
 #include "StringBase.h"
 #include "StringFeatures.h"
-#include "common/StringFromXMLParser.h"
-#include "common/StringToXMLComposer.h"
 #include <exception/CommonException.h>
 #include <alphabet/common/SymbolNormalize.h>
 
-#include "../tree/TreeFeatures.h"
+#include <tree/TreeFeatures.h>
 
 #include <core/normalize.hpp>
 
@@ -119,10 +116,6 @@ public:
 		return xmlTagName;
 	}
 
-	static LinearString parse ( ext::deque < sax::Token >::iterator & input );
-
-	static void compose ( ext::deque < sax::Token > & out, const LinearString & string );
-
 	virtual alib::ObjectBase * inc ( ) &&;
 
 	typedef LinearString < > normalized_type;
@@ -287,24 +280,6 @@ LinearString < SymbolType >::operator std::string ( ) const {
 	return std::move ( ss ).str ( );
 }
 
-template < class SymbolType >
-LinearString < SymbolType > LinearString < SymbolType >::parse ( ext::deque < sax::Token >::iterator & input ) {
-	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, LinearString::getXmlTagName() );
-	ext::set < SymbolType > alphabet = StringFromXMLParser::parseAlphabet < SymbolType > ( input );
-	ext::vector < SymbolType > content = StringFromXMLParser::parseContent < SymbolType > ( input );
-	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, LinearString::getXmlTagName() );
-
-	return LinearString < SymbolType > ( alphabet, content );
-}
-
-template < class SymbolType >
-void LinearString < SymbolType >::compose ( ext::deque < sax::Token > & out, const LinearString & string ) {
-	out.emplace_back ( LinearString::getXmlTagName(), sax::Token::TokenType::START_ELEMENT );
-	StringToXMLComposer::compose ( out, string.getAlphabet() );
-	StringToXMLComposer::compose ( out, string.m_Data );
-	out.emplace_back ( LinearString::getXmlTagName(), sax::Token::TokenType::END_ELEMENT );
-}
-
 template < class SymbolType >
 alib::ObjectBase* LinearString < SymbolType >::inc() && {
 	return new alib::UniqueObject(alib::Object(std::move(*this)), primitive::Integer(0));
diff --git a/alib2data/src/string/StringBase.h b/alib2data/src/string/StringBase.h
index 5d6098657b6908f550c6f3a475b13033ef74d620..5f5493388a3859765362cf2fcdbc23aa7e67f93e 100644
--- a/alib2data/src/string/StringBase.h
+++ b/alib2data/src/string/StringBase.h
@@ -10,8 +10,6 @@
 
 #include <object/ObjectBase.h>
 
-#include <core/xmlApi.hpp>
-
 namespace string {
 
 /**
@@ -25,28 +23,4 @@ public:
 
 } /* namespace string */
 
-namespace alib {
-
-template < typename Type >
-struct xmlApi < Type, typename std::enable_if < std::is_base_of < string::StringBase, Type >::value >::type > {
-	static Type parse ( ext::deque < sax::Token >::iterator & input ) {
-		return Type::parse ( input );
-	}
-
-	static bool first ( const ext::deque < sax::Token >::const_iterator & input ) {
-		return sax::FromXMLParserHelper::isToken ( input, sax::Token::TokenType::START_ELEMENT, xmlTagName() );
-	}
-
-	static std::string xmlTagName ( ) {
-		return Type::getXmlTagName();
-	}
-
-	static void compose ( ext::deque < sax::Token > & output, const Type & data ) {
-		Type::compose ( output, data );
-	}
-
-};
-
-} /* namespace alib */
-
 #endif /* STRING_BASE_H_ */
diff --git a/alib2data/src/string/common/StringFromXMLParser.h b/alib2data/src/string/common/StringFromXMLParser.h
deleted file mode 100644
index 75bdf0911cb85efb56b2b43555785cb962a89b76..0000000000000000000000000000000000000000
--- a/alib2data/src/string/common/StringFromXMLParser.h
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * StringFromXMLParser.h
- *
- *  Created on: Nov 23, 2013
- *      Author: Jan Travnicek
- */
-
-#ifndef STRING_FROM_XML_PARSER_H_
-#define STRING_FROM_XML_PARSER_H_
-
-#include <vector>
-#include <set>
-#include <deque>
-#include <sax/Token.h>
-#include <sax/FromXMLParserHelper.h>
-#include <core/xmlApi.hpp>
-
-namespace string {
-
-/**
- * Parser used to get String from XML parsed into list of tokens.
- */
-class StringFromXMLParser {
-public:
-	template < class SymbolType >
-	static ext::vector<SymbolType> parseContent(ext::deque<sax::Token>::iterator& input);
-	template < class SymbolType >
-	static ext::set<SymbolType> parseAlphabet(ext::deque<sax::Token>::iterator& input);
-};
-
-template < class SymbolType >
-ext::set<SymbolType> StringFromXMLParser::parseAlphabet(ext::deque<sax::Token>::iterator& input) {
-	ext::set<SymbolType> alphabet;
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "alphabet");
-	while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
-		alphabet.insert(alib::xmlApi<SymbolType>::parse(input));
-	}
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "alphabet");
-	return alphabet;
-}
-
-template < class SymbolType >
-ext::vector<SymbolType> StringFromXMLParser::parseContent(ext::deque<sax::Token>::iterator& input) {
-	ext::vector<SymbolType> data;
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "content");
-	while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
-		data.push_back(alib::xmlApi<SymbolType>::parse(input));
-	}
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "content");
-	return data;
-}
-
-} /* namespace string */
-
-#endif /* STRING_FROM_XML_PARSER_H_ */
diff --git a/alib2data/src/string/common/StringToXMLComposer.h b/alib2data/src/string/common/StringToXMLComposer.h
deleted file mode 100644
index 6dfcdad2984bd68dbb3b6ccf1252041c0e35933f..0000000000000000000000000000000000000000
--- a/alib2data/src/string/common/StringToXMLComposer.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * StringToXMLComposer.h
- *
- *  Created on: Nov 23, 2013
- *      Author: Jan Travnciek
- */
-
-#ifndef STRING_TO_XML_COMPOSER_H_
-#define STRING_TO_XML_COMPOSER_H_
-
-#include <deque>
-#include <sax/Token.h>
-#include <set>
-#include <vector>
-#include <core/xmlApi.hpp>
-
-namespace string {
-
-/**
- * This class contains methods to print XML representation of string to the output stream.
- */
-class StringToXMLComposer {
-public:
-	template < class SymbolType >
-	static void compose(ext::deque<sax::Token>& out, const ext::set<SymbolType>& alphabet);
-	template < class SymbolType >
-	static void compose(ext::deque<sax::Token>& out, const ext::vector<SymbolType>& content);
-};
-
-template < class SymbolType >
-void StringToXMLComposer::compose(ext::deque<sax::Token>& out, const ext::set<SymbolType>& alphabet) {
-	out.emplace_back("alphabet", sax::Token::TokenType::START_ELEMENT);
-	for (const auto& symbol : alphabet) {
-		alib::xmlApi<SymbolType>::compose(out, symbol);
-	}
-	out.emplace_back("alphabet", sax::Token::TokenType::END_ELEMENT);
-}
-
-template < class SymbolType >
-void StringToXMLComposer::compose(ext::deque<sax::Token>& out, const ext::vector<SymbolType>& content) {
-	out.emplace_back("content", sax::Token::TokenType::START_ELEMENT);
-	for(const auto& symbol : content) {
-		alib::xmlApi<SymbolType>::compose(out, symbol);
-	}
-	out.emplace_back("content", sax::Token::TokenType::END_ELEMENT);
-}
-
-} /* namespace string */
-
-#endif /* STRING_TO_XML_COMPOSER_H_ */
diff --git a/alib2data/src/string/xml/CyclicString.cpp b/alib2data/src/string/xml/CyclicString.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..543756a51d15b89650d926e6b42a88d5b38f2fe8
--- /dev/null
+++ b/alib2data/src/string/xml/CyclicString.cpp
@@ -0,0 +1,23 @@
+/*
+ * CyclicString.cpp
+ *
+ *  Created on: Nov 23, 2013
+ *	  Author: Jan Travnicek
+ */
+
+#include "CyclicString.h"
+
+#include <string/String.h>
+#include <object/Object.h>
+
+#include <registration/XmlRegistration.hpp>
+
+namespace {
+
+static auto xmlWrite = registration::XmlWriterRegister < string::String, string::CyclicString < > > ( );
+static auto xmlWrite2 = registration::XmlWriterRegister < alib::Object, string::CyclicString < > > ( );
+
+static auto xmlReader = registration::XmlReaderRegister < string::String, string::CyclicString < > > ( );
+static auto xmlReaded2 = registration::XmlReaderRegister < alib::Object, string::CyclicString < > > ( );
+
+} /* namespace */
diff --git a/alib2data/src/string/xml/CyclicString.h b/alib2data/src/string/xml/CyclicString.h
new file mode 100644
index 0000000000000000000000000000000000000000..d68a92385696c5a164e1452d0b55d80dee06cf57
--- /dev/null
+++ b/alib2data/src/string/xml/CyclicString.h
@@ -0,0 +1,58 @@
+/*
+ * CyclicString.h
+ *
+ * Created on: Dec 1, 2017
+ * Author: Jan Travnicek
+ */
+
+#ifndef _XML_CYCLIC_STRING_H_
+#define _XML_CYCLIC_STRING_H_
+
+#include <string/CyclicString.h>
+#include <core/xmlApi.hpp>
+
+#include <string/xml/common/StringFromXmlParserCommon.h>
+#include <string/xml/common/StringToXmlComposerCommon.h>
+
+namespace alib {
+
+template < typename SymbolType >
+struct xmlApi < string::CyclicString < SymbolType > > {
+	static string::CyclicString < SymbolType > parse ( ext::deque < sax::Token >::iterator & input );
+	static bool first ( const ext::deque < sax::Token >::const_iterator & input );
+	static const std::string & xmlTagName ( );
+	static void compose ( ext::deque < sax::Token > & output, const string::CyclicString < SymbolType > & data );
+};
+
+template < typename SymbolType >
+string::CyclicString < SymbolType > xmlApi < string::CyclicString < SymbolType > >::parse ( ext::deque < sax::Token >::iterator & input ) {
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, xmlTagName ( ) );
+	ext::set<SymbolType> alphabet = string::StringFromXmlParserCommon::parseAlphabet < SymbolType > ( input );
+	ext::vector<SymbolType> content = string::StringFromXmlParserCommon::parseContent < SymbolType > ( input );
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, xmlTagName ( ) );
+	return string::CyclicString < SymbolType > ( std::move ( alphabet ), std::move ( content ) );
+}
+
+template < typename SymbolType >
+bool xmlApi < string::CyclicString < SymbolType > >::first ( const ext::deque < sax::Token >::const_iterator & input ) {
+	return sax::FromXMLParserHelper::isToken ( input, sax::Token::TokenType::START_ELEMENT, xmlTagName ( ) );
+}
+
+template < typename SymbolType >
+const std::string & xmlApi < string::CyclicString < SymbolType > >::xmlTagName ( ) {
+	static std::string xmlTagName = "CyclicString";
+
+	return xmlTagName;
+}
+
+template < typename SymbolType >
+void xmlApi < string::CyclicString < SymbolType > >::compose ( ext::deque < sax::Token > & output, const string::CyclicString < SymbolType > & input ) {
+	output.emplace_back ( xmlTagName ( ), sax::Token::TokenType::START_ELEMENT );
+	string::StringToXmlComposerCommon::compose ( output, input.getAlphabet ( ) );
+	string::StringToXmlComposerCommon::compose ( output, input.getContent ( ) );
+	output.emplace_back ( xmlTagName ( ), sax::Token::TokenType::END_ELEMENT );
+}
+
+} /* namespace alib */
+
+#endif /* _XML_CYCLIC_STRING_H_ */
diff --git a/alib2data/src/string/xml/Epsilon.cpp b/alib2data/src/string/xml/Epsilon.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..93dbd07e0d6d43c579dec3948e41ad2fa529c862
--- /dev/null
+++ b/alib2data/src/string/xml/Epsilon.cpp
@@ -0,0 +1,23 @@
+/*
+ * Epsilon.cpp
+ *
+ *  Created on: Jan 30, 2014
+ *      Author: Jan Travnicek
+ */
+
+#include "Epsilon.h"
+
+#include <string/String.h>
+#include <object/Object.h>
+
+#include <registration/XmlRegistration.hpp>
+
+namespace {
+
+static auto xmlWrite = registration::XmlWriterRegister < string::String, string::Epsilon < > > ( );
+static auto xmlWrite2 = registration::XmlWriterRegister < alib::Object, string::Epsilon < > > ( );
+
+static auto xmlReader = registration::XmlReaderRegister < string::String, string::Epsilon < > > ( );
+static auto xmlReaded2 = registration::XmlReaderRegister < alib::Object, string::Epsilon < > > ( );
+
+} /* namespace */
diff --git a/alib2data/src/string/xml/Epsilon.h b/alib2data/src/string/xml/Epsilon.h
new file mode 100644
index 0000000000000000000000000000000000000000..8431330213b49de8e1e594aa03ae8a7a92c7b039
--- /dev/null
+++ b/alib2data/src/string/xml/Epsilon.h
@@ -0,0 +1,56 @@
+/*
+ * Epsilon.h
+ *
+ * Created on: Dec 1, 2017
+ * Author: Jan Travnicek
+ */
+
+#ifndef _XML_EPSILON_H_
+#define _XML_EPSILON_H_
+
+#include <string/Epsilon.h>
+#include <core/xmlApi.hpp>
+
+#include <string/xml/common/StringFromXmlParserCommon.h>
+#include <string/xml/common/StringToXmlComposerCommon.h>
+
+namespace alib {
+
+template < typename SymbolType >
+struct xmlApi < string::Epsilon < SymbolType > > {
+	static string::Epsilon < SymbolType > parse ( ext::deque < sax::Token >::iterator & input );
+	static bool first ( const ext::deque < sax::Token >::const_iterator & input );
+	static const std::string & xmlTagName ( );
+	static void compose ( ext::deque < sax::Token > & output, const string::Epsilon < SymbolType > & data );
+};
+
+template < typename SymbolType >
+string::Epsilon < SymbolType > xmlApi < string::Epsilon < SymbolType > >::parse ( ext::deque < sax::Token >::iterator & input ) {
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, xmlTagName ( ) );
+	ext::set < SymbolType > alphabet = string::StringFromXmlParserCommon::parseAlphabet < SymbolType > ( input );
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, xmlTagName ( ) );
+	return string::Epsilon < SymbolType > ( std::move ( alphabet ) );
+}
+
+template < typename SymbolType >
+bool xmlApi < string::Epsilon < SymbolType > >::first ( const ext::deque < sax::Token >::const_iterator & input ) {
+	return sax::FromXMLParserHelper::isToken ( input, sax::Token::TokenType::START_ELEMENT, xmlTagName ( ) );
+}
+
+template < typename SymbolType >
+const std::string & xmlApi < string::Epsilon < SymbolType > >::xmlTagName ( ) {
+	static std::string xmlTagName = "Epsilon";
+
+	return xmlTagName;
+}
+
+template < typename SymbolType >
+void xmlApi < string::Epsilon < SymbolType > >::compose ( ext::deque < sax::Token > & output, const string::Epsilon < SymbolType > & input ) {
+	output.emplace_back ( xmlTagName ( ), sax::Token::TokenType::START_ELEMENT );
+	string::StringToXmlComposerCommon::compose ( output, input.getAlphabet ( ) );
+	output.emplace_back ( xmlTagName ( ), sax::Token::TokenType::END_ELEMENT );
+}
+
+} /* namespace alib */
+
+#endif /* _XML_EPSILON_H_ */
diff --git a/alib2data/src/string/xml/LinearString.cpp b/alib2data/src/string/xml/LinearString.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ec909558894e5363576832a205da3321c87e7069
--- /dev/null
+++ b/alib2data/src/string/xml/LinearString.cpp
@@ -0,0 +1,23 @@
+/*
+ * LinearString.cpp
+ *
+ *  Created on: Nov 23, 2013
+ *      Author: Jan Travnicek
+ */
+
+#include "LinearString.h"
+
+#include <string/String.h>
+#include <object/Object.h>
+
+#include <registration/XmlRegistration.hpp>
+
+namespace {
+
+static auto xmlWrite = registration::XmlWriterRegister < string::String, string::LinearString < > > ( );
+static auto xmlWrite2 = registration::XmlWriterRegister < alib::Object, string::LinearString < > > ( );
+
+static auto xmlReader = registration::XmlReaderRegister < string::String, string::LinearString < > > ( );
+static auto xmlReaded2 = registration::XmlReaderRegister < alib::Object, string::LinearString < > > ( );
+
+} /* namespace */
diff --git a/alib2data/src/string/xml/LinearString.h b/alib2data/src/string/xml/LinearString.h
new file mode 100644
index 0000000000000000000000000000000000000000..490383ce40371ead5c3b649198bda40f3e4fc637
--- /dev/null
+++ b/alib2data/src/string/xml/LinearString.h
@@ -0,0 +1,58 @@
+/*
+ * LinearString.h
+ *
+ * Created on: Dec 1, 2017
+ * Author: Jan Travnicek
+ */
+
+#ifndef _XML_LINEAR_STRING_H_
+#define _XML_LINEAR_STRING_H_
+
+#include <string/LinearString.h>
+#include <core/xmlApi.hpp>
+
+#include <string/xml/common/StringFromXmlParserCommon.h>
+#include <string/xml/common/StringToXmlComposerCommon.h>
+
+namespace alib {
+
+template < typename SymbolType >
+struct xmlApi < string::LinearString < SymbolType > > {
+	static string::LinearString < SymbolType > parse ( ext::deque < sax::Token >::iterator & input );
+	static bool first ( const ext::deque < sax::Token >::const_iterator & input );
+	static const std::string & xmlTagName ( );
+	static void compose ( ext::deque < sax::Token > & output, const string::LinearString < SymbolType > & data );
+};
+
+template < typename SymbolType >
+string::LinearString < SymbolType > xmlApi < string::LinearString < SymbolType > >::parse ( ext::deque < sax::Token >::iterator & input ) {
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, xmlTagName ( ) );
+	ext::set<SymbolType> alphabet = string::StringFromXmlParserCommon::parseAlphabet < SymbolType > ( input );
+	ext::vector<SymbolType> content = string::StringFromXmlParserCommon::parseContent < SymbolType > ( input );
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, xmlTagName ( ) );
+	return string::LinearString < SymbolType > ( std::move ( alphabet ), std::move ( content ) );
+}
+
+template < typename SymbolType >
+bool xmlApi < string::LinearString < SymbolType > >::first ( const ext::deque < sax::Token >::const_iterator & input ) {
+	return sax::FromXMLParserHelper::isToken ( input, sax::Token::TokenType::START_ELEMENT, xmlTagName ( ) );
+}
+
+template < typename SymbolType >
+const std::string & xmlApi < string::LinearString < SymbolType > >::xmlTagName ( ) {
+	static std::string xmlTagName = "LinearString";
+
+	return xmlTagName;
+}
+
+template < typename SymbolType >
+void xmlApi < string::LinearString < SymbolType > >::compose ( ext::deque < sax::Token > & output, const string::LinearString < SymbolType > & input ) {
+	output.emplace_back ( xmlTagName ( ), sax::Token::TokenType::START_ELEMENT );
+	string::StringToXmlComposerCommon::compose ( output, input.getAlphabet ( ) );
+	string::StringToXmlComposerCommon::compose ( output, input.getContent ( ) );
+	output.emplace_back ( xmlTagName ( ), sax::Token::TokenType::END_ELEMENT );
+}
+
+} /* namespace alib */
+
+#endif /* _XML_LINEAR_STRING_H_ */
diff --git a/alib2data/src/string/xml/common/StringFromXmlParserCommon.h b/alib2data/src/string/xml/common/StringFromXmlParserCommon.h
new file mode 100644
index 0000000000000000000000000000000000000000..fc021708c193a5b73eee8a91c60d9da949e4a45c
--- /dev/null
+++ b/alib2data/src/string/xml/common/StringFromXmlParserCommon.h
@@ -0,0 +1,61 @@
+/*
+ * StringFromXmlParserCommon.h
+ *
+ *  Created on: Nov 23, 2013
+ *      Author: Jan Travnicek
+ */
+
+#ifndef STRING_FROM_XML_PARSER_COMMON_H_
+#define STRING_FROM_XML_PARSER_COMMON_H_
+
+#include <vector>
+#include <set>
+#include <deque>
+#include <sax/Token.h>
+#include <sax/FromXMLParserHelper.h>
+#include <core/xmlApi.hpp>
+
+namespace string {
+
+/**
+ * Parser used to get String from Xml parsed into list of tokens.
+ */
+class StringFromXmlParserCommon {
+public:
+	template < class SymbolType >
+	static ext::vector < SymbolType > parseContent ( ext::deque < sax::Token >::iterator & input );
+	template < class SymbolType >
+	static ext::set < SymbolType > parseAlphabet ( ext::deque < sax::Token >::iterator & input );
+};
+
+template < class SymbolType >
+ext::set < SymbolType > StringFromXmlParserCommon::parseAlphabet ( ext::deque < sax::Token >::iterator & input ) {
+	ext::set < SymbolType > alphabet;
+
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, "alphabet" );
+
+	while ( sax::FromXMLParserHelper::isTokenType ( input, sax::Token::TokenType::START_ELEMENT ) )
+		alphabet.insert ( alib::xmlApi < SymbolType >::parse ( input ) );
+
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, "alphabet" );
+
+	return alphabet;
+}
+
+template < class SymbolType >
+ext::vector < SymbolType > StringFromXmlParserCommon::parseContent ( ext::deque < sax::Token >::iterator & input ) {
+	ext::vector < SymbolType > data;
+
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, "content" );
+
+	while ( sax::FromXMLParserHelper::isTokenType ( input, sax::Token::TokenType::START_ELEMENT ) )
+		data.push_back ( alib::xmlApi < SymbolType >::parse ( input ) );
+
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, "content" );
+
+	return data;
+}
+
+} /* namespace string */
+
+#endif /* STRING_FROM_XML_PARSER_COMMON_H_ */
diff --git a/alib2data/src/string/xml/common/StringToXmlComposerCommon.h b/alib2data/src/string/xml/common/StringToXmlComposerCommon.h
new file mode 100644
index 0000000000000000000000000000000000000000..7fd88b0f15d4b5991bfad6a81093cfdbc0d4e540
--- /dev/null
+++ b/alib2data/src/string/xml/common/StringToXmlComposerCommon.h
@@ -0,0 +1,52 @@
+/*
+ * StringToXmlComposerCommon.h
+ *
+ *  Created on: Nov 23, 2013
+ *      Author: Jan Travnciek
+ */
+
+#ifndef STRING_TO_XML_COMPOSER_COMMON_H_
+#define STRING_TO_XML_COMPOSER_COMMON_H_
+
+#include <deque>
+#include <sax/Token.h>
+#include <set>
+#include <vector>
+#include <core/xmlApi.hpp>
+
+namespace string {
+
+/**
+ * This class contains methods to print Xml representation of string to the output stream.
+ */
+class StringToXmlComposerCommon {
+public:
+	template < class SymbolType >
+	static void compose ( ext::deque < sax::Token > & out, const ext::set < SymbolType > & alphabet );
+	template < class SymbolType >
+	static void compose ( ext::deque < sax::Token > & out, const ext::vector < SymbolType > & content );
+};
+
+template < class SymbolType >
+void StringToXmlComposerCommon::compose ( ext::deque < sax::Token > & out, const ext::set < SymbolType > & alphabet ) {
+	out.emplace_back ( "alphabet", sax::Token::TokenType::START_ELEMENT );
+
+	for ( const SymbolType & symbol : alphabet )
+		alib::xmlApi < SymbolType >::compose ( out, symbol );
+
+	out.emplace_back ( "alphabet", sax::Token::TokenType::END_ELEMENT );
+}
+
+template < class SymbolType >
+void StringToXmlComposerCommon::compose(ext::deque<sax::Token>& out, const ext::vector<SymbolType>& content) {
+	out.emplace_back ( "content", sax::Token::TokenType::START_ELEMENT );
+
+	for ( const SymbolType & symbol : content )
+		alib::xmlApi < SymbolType >::compose ( out, symbol );
+
+	out.emplace_back ( "content", sax::Token::TokenType::END_ELEMENT );
+}
+
+} /* namespace string */
+
+#endif /* STRING_TO_XML_COMPOSER_COMMON_H_ */
diff --git a/alib2data/test-src/string/StringTest.cpp b/alib2data/test-src/string/StringTest.cpp
index e5b09557fd4393ac2d21340453cba67145863c66..3ba87b1d20cd7a9905e58da54f23c4a80548877f 100644
--- a/alib2data/test-src/string/StringTest.cpp
+++ b/alib2data/test-src/string/StringTest.cpp
@@ -7,8 +7,11 @@
 
 #include "string/String.h"
 #include "string/LinearString.h"
+#include "string/xml/LinearString.h"
 #include "string/CyclicString.h"
+#include "string/xml/CyclicString.h"
 #include "string/Epsilon.h"
+#include "string/xml/Epsilon.h"
 
 #include "factory/XmlDataFactory.hpp"
 
diff --git a/alib2data_experimental/src/string/LinearStringTerminatingSymbol.cpp b/alib2data_experimental/src/string/LinearStringTerminatingSymbol.cpp
index 0542dcd2f4568f363a6a4b0777a2528db184314d..57e0789a572bedbc4c85209a092d2e603a65ba8c 100644
--- a/alib2data_experimental/src/string/LinearStringTerminatingSymbol.cpp
+++ b/alib2data_experimental/src/string/LinearStringTerminatingSymbol.cpp
@@ -13,8 +13,8 @@
 #include <algorithm>
 
 #include <sax/FromXMLParserHelper.h>
-#include <string/common/StringFromXMLParser.h>
-#include <string/common/StringToXMLComposer.h>
+#include <string/xml/common/StringFromXmlParserCommon.h>
+#include <string/xml/common/StringToXmlComposerCommon.h>
 #include <string/String.h>
 #include <object/Object.h>
 #include <object/UniqueObject.h>
@@ -100,29 +100,43 @@ LinearStringTerminatingSymbol::operator std::string ( ) const {
 	return std::move ( ss ).str ( );
 }
 
-LinearStringTerminatingSymbol LinearStringTerminatingSymbol::parse ( ext::deque < sax::Token >::iterator & input ) {
-	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, LinearStringTerminatingSymbol::getXmlTagName() );
-	ext::set < DefaultSymbolType > alphabet = StringFromXMLParser::parseAlphabet < DefaultSymbolType > ( input );
+alib::ObjectBase* LinearStringTerminatingSymbol::inc() && {
+	return new alib::UniqueObject(alib::Object(std::move(*this)), primitive::Integer(0));
+}
+
+} /* namespace string */
+
+namespace alib {
+
+string::LinearStringTerminatingSymbol xmlApi < string::LinearStringTerminatingSymbol >::parse ( ext::deque < sax::Token >::iterator & input ) {
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, xmlTagName ( ) );
+	ext::set < DefaultSymbolType > alphabet = string::StringFromXmlParserCommon::parseAlphabet < DefaultSymbolType > ( input );
 	DefaultSymbolType terminatingSymbol = alib::xmlApi < DefaultSymbolType >::parse ( input );
-	ext::vector < DefaultSymbolType > content = StringFromXMLParser::parseContent < DefaultSymbolType > ( input );
-	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, LinearStringTerminatingSymbol::getXmlTagName() );
+	ext::vector < DefaultSymbolType > content = string::StringFromXmlParserCommon::parseContent < DefaultSymbolType > ( input );
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, xmlTagName ( ) );
 
-	return LinearStringTerminatingSymbol ( alphabet, terminatingSymbol, content );
+	return string::LinearStringTerminatingSymbol ( alphabet, terminatingSymbol, content );
 }
 
-void LinearStringTerminatingSymbol::compose ( ext::deque < sax::Token > & out, const LinearStringTerminatingSymbol & string ) {
-	out.emplace_back ( LinearStringTerminatingSymbol::getXmlTagName(), sax::Token::TokenType::START_ELEMENT );
-	StringToXMLComposer::compose ( out, string.getAlphabet() );
-	alib::xmlApi < DefaultSymbolType >::compose ( out, string.getTerminatingSymbol ( ) );
-	StringToXMLComposer::compose ( out, string.m_Data );
-	out.emplace_back ( LinearStringTerminatingSymbol::getXmlTagName(), sax::Token::TokenType::END_ELEMENT );
+bool xmlApi < string::LinearStringTerminatingSymbol >::first ( const ext::deque < sax::Token >::const_iterator & input ) {
+	return sax::FromXMLParserHelper::isToken ( input, sax::Token::TokenType::START_ELEMENT, xmlTagName ( ) );
 }
 
-alib::ObjectBase* LinearStringTerminatingSymbol::inc() && {
-	return new alib::UniqueObject(alib::Object(std::move(*this)), primitive::Integer(0));
+const std::string & xmlApi < string::LinearStringTerminatingSymbol >::xmlTagName ( ) {
+	static std::string xmlTagName = "LinearStringTerminatingSymbol";
+
+	return xmlTagName;
 }
 
-} /* namespace string */
+void xmlApi < string::LinearStringTerminatingSymbol >::compose ( ext::deque < sax::Token > & output, const string::LinearStringTerminatingSymbol & data ) {
+	output.emplace_back ( xmlTagName ( ), sax::Token::TokenType::START_ELEMENT );
+	string::StringToXmlComposerCommon::compose ( output, data.getAlphabet() );
+	alib::xmlApi < DefaultSymbolType >::compose ( output, data.getTerminatingSymbol ( ) );
+	string::StringToXmlComposerCommon::compose ( output, data.getContent ( ) );
+	output.emplace_back ( xmlTagName ( ), sax::Token::TokenType::END_ELEMENT );
+}
+
+} /* namespace alib */
 
 namespace {
 
diff --git a/alib2data_experimental/src/string/LinearStringTerminatingSymbol.h b/alib2data_experimental/src/string/LinearStringTerminatingSymbol.h
index 353fc281e079b4ac2adfb8581af14903e4716343..cf56b295120e27484bf0411157e074d9aacb249c 100644
--- a/alib2data_experimental/src/string/LinearStringTerminatingSymbol.h
+++ b/alib2data_experimental/src/string/LinearStringTerminatingSymbol.h
@@ -11,6 +11,7 @@
 #include <iostream>
 #include <set>
 #include <vector>
+#include <deque>
 
 #include <string/StringBase.h>
 #include <string/StringFeatures.h>
@@ -18,6 +19,9 @@
 #include <alphabet/Symbol.h>
 #include <core/components.hpp>
 
+#include <sax/Token.h>
+#include <core/xmlApi.hpp>
+
 namespace string {
 
 class GeneralAlphabet;
@@ -80,16 +84,6 @@ public:
 
 	virtual explicit operator std::string ( ) const;
 
-	static const std::string & getXmlTagName() {
-		static std::string xmlTagName = "LinearStringTerminatingSymbol";
-
-		return xmlTagName;
-	}
-
-	static LinearStringTerminatingSymbol parse ( ext::deque < sax::Token >::iterator & input );
-
-	static void compose ( ext::deque < sax::Token > & out, const LinearStringTerminatingSymbol & string );
-
 	virtual alib::ObjectBase * inc ( ) &&;
 
 	typedef LinearStringTerminatingSymbol normalized_type;
@@ -100,29 +94,37 @@ public:
 namespace alib {
 
 template < >
-class SetConstraint< ::string::LinearStringTerminatingSymbol, DefaultSymbolType, ::string::GeneralAlphabet > {
+struct xmlApi < string::LinearStringTerminatingSymbol > {
+	static string::LinearStringTerminatingSymbol parse ( ext::deque < sax::Token >::iterator & input );
+	static bool first ( const ext::deque < sax::Token >::const_iterator & input );
+	static const std::string & xmlTagName ( );
+	static void compose ( ext::deque < sax::Token > & output, const string::LinearStringTerminatingSymbol & data );
+};
+
+template < >
+class SetConstraint< string::LinearStringTerminatingSymbol, DefaultSymbolType, string::GeneralAlphabet > {
 public:
-	static bool used ( const ::string::LinearStringTerminatingSymbol & str, const DefaultSymbolType & symbol ) {
+	static bool used ( const string::LinearStringTerminatingSymbol & str, const DefaultSymbolType & symbol ) {
 		const ext::vector<DefaultSymbolType>& content = str.getContent ( );
 		return std::find(content.begin(), content.end(), symbol) != content.end();
 	}
 
-	static bool available ( const ::string::LinearStringTerminatingSymbol &, const DefaultSymbolType & ) {
+	static bool available ( const string::LinearStringTerminatingSymbol &, const DefaultSymbolType & ) {
 		return true;
 	}
 
-	static void valid ( const ::string::LinearStringTerminatingSymbol &, const DefaultSymbolType & ) {
+	static void valid ( const string::LinearStringTerminatingSymbol &, const DefaultSymbolType & ) {
 	}
 };
 
 template < >
-class ElementConstraint< ::string::LinearStringTerminatingSymbol, DefaultSymbolType, ::string::TerminatingSymbol > {
+class ElementConstraint< string::LinearStringTerminatingSymbol, DefaultSymbolType, string::TerminatingSymbol > {
 public:
-	static bool available ( const ::string::LinearStringTerminatingSymbol & str, const DefaultSymbolType & symbol ) {
+	static bool available ( const string::LinearStringTerminatingSymbol & str, const DefaultSymbolType & symbol ) {
 		return str.getAlphabet ( ).count ( symbol );
 	}
 
-	static void valid ( const ::string::LinearStringTerminatingSymbol &, const DefaultSymbolType & ) {
+	static void valid ( const string::LinearStringTerminatingSymbol &, const DefaultSymbolType & ) {
 	}
 };