diff --git a/alib2data_experimental/src/string/LinearStringTerminatingSymbol.cpp b/alib2data_experimental/src/string/LinearStringTerminatingSymbol.cpp
index 9e78fe3e515181d1608b48c135436970e711abc0..90861eb5d51287d3b2a220668668d250c3ccc9fb 100644
--- a/alib2data_experimental/src/string/LinearStringTerminatingSymbol.cpp
+++ b/alib2data_experimental/src/string/LinearStringTerminatingSymbol.cpp
@@ -23,17 +23,17 @@
 
 namespace string {
 
-LinearStringTerminatingSymbol::LinearStringTerminatingSymbol ( std::set < alphabet::Symbol > alphabet, alphabet::Symbol terminatingSymbol, std::vector < alphabet::Symbol > data ) : std::Components < LinearStringTerminatingSymbol, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < TerminatingSymbol > > ( std::make_tuple ( std::move ( alphabet ) ), std::make_tuple ( std::move ( terminatingSymbol ) ) ) {
+LinearStringTerminatingSymbol::LinearStringTerminatingSymbol ( std::set < DefaultSymbolType > alphabet, DefaultSymbolType terminatingSymbol, std::vector < DefaultSymbolType > data ) : std::Components < LinearStringTerminatingSymbol, DefaultSymbolType, std::tuple < GeneralAlphabet >, std::tuple < TerminatingSymbol > > ( std::make_tuple ( std::move ( alphabet ) ), std::make_tuple ( std::move ( terminatingSymbol ) ) ) {
 	setContent ( std::move ( data ) );
 }
 
-LinearStringTerminatingSymbol::LinearStringTerminatingSymbol ( alphabet::Symbol terminatingSymbol ) : LinearStringTerminatingSymbol ( std::set < alphabet::Symbol > { terminatingSymbol }, terminatingSymbol, std::vector < alphabet::Symbol > ( ) ) {
+LinearStringTerminatingSymbol::LinearStringTerminatingSymbol ( DefaultSymbolType terminatingSymbol ) : LinearStringTerminatingSymbol ( std::set < DefaultSymbolType > { terminatingSymbol }, terminatingSymbol, std::vector < DefaultSymbolType > ( ) ) {
 }
 
-LinearStringTerminatingSymbol::LinearStringTerminatingSymbol ( alphabet::Symbol terminatingSymbol, std::vector < alphabet::Symbol > data ) : LinearStringTerminatingSymbol ( std::set < alphabet::Symbol > ( data.begin ( ), data.end ( ) ) + std::set < alphabet::Symbol > { terminatingSymbol }, terminatingSymbol, data ) {
+LinearStringTerminatingSymbol::LinearStringTerminatingSymbol ( DefaultSymbolType terminatingSymbol, std::vector < DefaultSymbolType > data ) : LinearStringTerminatingSymbol ( std::set < DefaultSymbolType > ( data.begin ( ), data.end ( ) ) + std::set < DefaultSymbolType > { terminatingSymbol }, terminatingSymbol, data ) {
 }
 
-LinearStringTerminatingSymbol::LinearStringTerminatingSymbol ( alphabet::Symbol terminatingSymbol, const LinearString < > & str ) : LinearStringTerminatingSymbol ( str.getAlphabet( ), std::move ( terminatingSymbol ), str.getContent ( ) ) {
+LinearStringTerminatingSymbol::LinearStringTerminatingSymbol ( DefaultSymbolType terminatingSymbol, const LinearString < > & str ) : LinearStringTerminatingSymbol ( str.getAlphabet( ), std::move ( terminatingSymbol ), str.getContent ( ) ) {
 }
 
 StringBase * LinearStringTerminatingSymbol::clone ( ) const {
@@ -44,20 +44,20 @@ StringBase * LinearStringTerminatingSymbol::plunder ( ) && {
 	return new LinearStringTerminatingSymbol ( std::move ( * this ) );
 }
 
-void LinearStringTerminatingSymbol::appendSymbol ( alphabet::Symbol symbol ) {
+void LinearStringTerminatingSymbol::appendSymbol ( DefaultSymbolType symbol ) {
 	if ( getAlphabet().count ( symbol ) == 0 )
 		throw exception::CommonException ( "Input symbol \"" + std::to_string ( symbol ) + "\" not in the alphabet." );
 
 	m_Data.push_back ( std::move ( symbol ) );
 }
 
-const std::vector < alphabet::Symbol > & LinearStringTerminatingSymbol::getContent ( ) const {
+const std::vector < DefaultSymbolType > & LinearStringTerminatingSymbol::getContent ( ) const {
 	return this->m_Data;
 }
 
-void LinearStringTerminatingSymbol::setContent ( std::vector < alphabet::Symbol > data ) {
-	std::set < alphabet::Symbol > minimalAlphabet ( data.begin ( ), data.end ( ) );
-	std::set < alphabet::Symbol > unknownSymbols;
+void LinearStringTerminatingSymbol::setContent ( std::vector < DefaultSymbolType > data ) {
+	std::set < DefaultSymbolType > minimalAlphabet ( data.begin ( ), data.end ( ) );
+	std::set < DefaultSymbolType > unknownSymbols;
 	std::set_difference ( minimalAlphabet.begin ( ), minimalAlphabet.end ( ), getAlphabet().begin ( ), getAlphabet().end ( ), std::inserter ( unknownSymbols, unknownSymbols.end ( ) ) );
 
 	if ( unknownSymbols.size ( ) > 0 )
@@ -82,7 +82,7 @@ int LinearStringTerminatingSymbol::compare ( const LinearStringTerminatingSymbol
 void LinearStringTerminatingSymbol::operator >>( std::ostream & out ) const {
 	out << "(LinearStringTerminatingSymbol ";
 
-	for ( const alphabet::Symbol & symbol : this->m_Data )
+	for ( const DefaultSymbolType & symbol : this->m_Data )
 		out << symbol;
 
 	out << ")";
@@ -92,7 +92,7 @@ LinearStringTerminatingSymbol::operator std::string ( ) const {
 	std::stringstream ss;
 	ss << "\"";
 
-	for ( const alphabet::Symbol & symbol : this->m_Data )
+	for ( const DefaultSymbolType & symbol : this->m_Data )
 		ss << symbol;
 
 	ss << "\"";
@@ -101,9 +101,9 @@ LinearStringTerminatingSymbol::operator std::string ( ) const {
 
 LinearStringTerminatingSymbol LinearStringTerminatingSymbol::parse ( std::deque < sax::Token >::iterator & input ) {
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, LinearStringTerminatingSymbol::getXmlTagName() );
-	std::set < alphabet::Symbol > alphabet = StringFromXMLParser::parseAlphabet < alphabet::Symbol > ( input );
-	alphabet::Symbol terminatingSymbol = alib::xmlApi < alphabet::Symbol >::parse ( input );
-	std::vector < alphabet::Symbol > content = StringFromXMLParser::parseContent < alphabet::Symbol > ( input );
+	std::set < DefaultSymbolType > alphabet = StringFromXMLParser::parseAlphabet < DefaultSymbolType > ( input );
+	DefaultSymbolType terminatingSymbol = alib::xmlApi < DefaultSymbolType >::parse ( input );
+	std::vector < DefaultSymbolType > content = StringFromXMLParser::parseContent < DefaultSymbolType > ( input );
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, LinearStringTerminatingSymbol::getXmlTagName() );
 
 	return LinearStringTerminatingSymbol ( alphabet, terminatingSymbol, content );
@@ -112,7 +112,7 @@ LinearStringTerminatingSymbol LinearStringTerminatingSymbol::parse ( std::deque
 void LinearStringTerminatingSymbol::compose ( std::deque < sax::Token > & out ) const {
 	out.emplace_back ( LinearStringTerminatingSymbol::getXmlTagName(), sax::Token::TokenType::START_ELEMENT );
 	StringToXMLComposer::compose ( out, getAlphabet() );
-	alib::xmlApi < alphabet::Symbol >::compose ( out, getTerminatingSymbol ( ) );
+	alib::xmlApi < DefaultSymbolType >::compose ( out, getTerminatingSymbol ( ) );
 	StringToXMLComposer::compose ( out, m_Data );
 	out.emplace_back ( LinearStringTerminatingSymbol::getXmlTagName(), sax::Token::TokenType::END_ELEMENT );
 }
diff --git a/alib2data_experimental/src/string/LinearStringTerminatingSymbol.h b/alib2data_experimental/src/string/LinearStringTerminatingSymbol.h
index e0dc3b7874f1853864ca8b5a04d6838ee3c1a0d9..717a1eb74afcb05b145626b7cf4ef1eb34116d51 100644
--- a/alib2data_experimental/src/string/LinearStringTerminatingSymbol.h
+++ b/alib2data_experimental/src/string/LinearStringTerminatingSymbol.h
@@ -27,41 +27,41 @@ class TerminatingSymbol;
  * Represents regular expression parsed from the XML. Regular expression is stored
  * as a tree of LinearStringElement.
  */
-class LinearStringTerminatingSymbol : public StringBase, public std::Components < LinearStringTerminatingSymbol, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < TerminatingSymbol > > {
-	std::vector < alphabet::Symbol > m_Data;
+class LinearStringTerminatingSymbol : public StringBase, public std::Components < LinearStringTerminatingSymbol, DefaultSymbolType, std::tuple < GeneralAlphabet >, std::tuple < TerminatingSymbol > > {
+	std::vector < DefaultSymbolType > m_Data;
 
 public:
-	explicit LinearStringTerminatingSymbol ( alphabet::Symbol terminatingSymbol );
-	explicit LinearStringTerminatingSymbol ( std::set < alphabet::Symbol > alphabet, alphabet::Symbol terminatingSymbol, std::vector < alphabet::Symbol > data );
-	explicit LinearStringTerminatingSymbol ( alphabet::Symbol terminatingSymbol, std::vector < alphabet::Symbol > data );
-	explicit LinearStringTerminatingSymbol ( alphabet::Symbol terminatingSymbol, const LinearString < > & str );
+	explicit LinearStringTerminatingSymbol ( DefaultSymbolType terminatingSymbol );
+	explicit LinearStringTerminatingSymbol ( std::set < DefaultSymbolType > alphabet, DefaultSymbolType terminatingSymbol, std::vector < DefaultSymbolType > data );
+	explicit LinearStringTerminatingSymbol ( DefaultSymbolType terminatingSymbol, std::vector < DefaultSymbolType > data );
+	explicit LinearStringTerminatingSymbol ( DefaultSymbolType terminatingSymbol, const LinearString < > & str );
 
 	virtual StringBase * clone ( ) const;
 	virtual StringBase * plunder ( ) &&;
 
-	virtual const std::set < alphabet::Symbol > & getAlphabet ( ) const {
+	virtual const std::set < DefaultSymbolType > & getAlphabet ( ) const {
 		return accessComponent < GeneralAlphabet > ( ).get ( );
 	}
 
-	void extendAlphabet ( const std::set < alphabet::Symbol > & symbols ) {
+	void extendAlphabet ( const std::set < DefaultSymbolType > & symbols ) {
 		accessComponent < GeneralAlphabet > ( ).add( symbols );
 	}
 
-	const alphabet::Symbol & getTerminatingSymbol ( ) const {
+	const DefaultSymbolType & getTerminatingSymbol ( ) const {
 		return accessElement < TerminatingSymbol > ( ).get ( );
 	}
 
 	/**
 	 * @param element to append
 	 */
-	void appendSymbol ( alphabet::Symbol symbol );
+	void appendSymbol ( DefaultSymbolType symbol );
 
 	/**
 	 * @return List of symbols forming string (const version).
 	 */
-	const std::vector < alphabet::Symbol > & getContent ( ) const;
+	const std::vector < DefaultSymbolType > & getContent ( ) const;
 
-	void setContent ( std::vector < alphabet::Symbol > data );
+	void setContent ( std::vector < DefaultSymbolType > data );
 
 	/**
 	 * @return true if string is an empty word (vector length is 0)
@@ -98,29 +98,29 @@ public:
 namespace std {
 
 template < >
-class ComponentConstraint< ::string::LinearStringTerminatingSymbol, alphabet::Symbol, ::string::GeneralAlphabet > {
+class ComponentConstraint< ::string::LinearStringTerminatingSymbol, DefaultSymbolType, ::string::GeneralAlphabet > {
 public:
-	static bool used ( const ::string::LinearStringTerminatingSymbol & str, const alphabet::Symbol & symbol ) {
-		const std::vector<alphabet::Symbol>& content = str.getContent ( );
+	static bool used ( const ::string::LinearStringTerminatingSymbol & str, const DefaultSymbolType & symbol ) {
+		const std::vector<DefaultSymbolType>& content = str.getContent ( );
 		return std::find(content.begin(), content.end(), symbol) != content.end();
 	}
 
-	static bool available ( const ::string::LinearStringTerminatingSymbol &, const alphabet::Symbol & ) {
+	static bool available ( const ::string::LinearStringTerminatingSymbol &, const DefaultSymbolType & ) {
 		return true;
 	}
 
-	static void valid ( const ::string::LinearStringTerminatingSymbol &, const alphabet::Symbol & ) {
+	static void valid ( const ::string::LinearStringTerminatingSymbol &, const DefaultSymbolType & ) {
 	}
 };
 
 template < >
-class ElementConstraint< ::string::LinearStringTerminatingSymbol, alphabet::Symbol, ::string::TerminatingSymbol > {
+class ElementConstraint< ::string::LinearStringTerminatingSymbol, DefaultSymbolType, ::string::TerminatingSymbol > {
 public:
-	static bool available ( const ::string::LinearStringTerminatingSymbol & str, const alphabet::Symbol & symbol ) {
+	static bool available ( const ::string::LinearStringTerminatingSymbol & str, const DefaultSymbolType & symbol ) {
 		return str.getAlphabet ( ).count ( symbol );
 	}
 
-	static void valid ( const ::string::LinearStringTerminatingSymbol &, const alphabet::Symbol & ) {
+	static void valid ( const ::string::LinearStringTerminatingSymbol &, const DefaultSymbolType & ) {
 	}
 };