From d954d0eb81f22b62f629e6d875ccce9df2e6426c Mon Sep 17 00:00:00 2001
From: Jan Travnicek <Jan.Travnicek@fit.cvut.cz>
Date: Tue, 21 Mar 2017 19:48:34 +0100
Subject: [PATCH] deduce template param when parsing by xml factory

---
 aaccess2/src/aaccess.cpp                      |  14 +-
 aaccess2/src/common/AccessHelpers.hpp         |   8 +-
 aarbology2/src/aarbology.cpp                  |  46 ++---
 acast2/src/acast.cpp                          |   2 +-
 acompaction2/src/acompaction.cpp              |   2 +-
 acompare2/src/acompare.cpp                    |   8 +-
 aconversions2/src/ConversionHandler.cpp       |  16 +-
 aconvert2/src/aconvert.cpp                    |  26 +--
 aderivation2/src/aderivation.cpp              |   4 +-
 adeterminize2/src/adeterminize.cpp            |   2 +-
 aecho2/src/aecho.cpp                          |   2 +-
 aepsilon2/src/aepsilon.cpp                    |   8 +-
 agenerate2/src/agenerate.cpp                  |   6 +-
 aintegral2/src/aintegral.cpp                  |   4 +-
 alangop2/src/alangop.cpp                      |  12 +-
 alib2algo/test-src/regexp/RegExpTest.cpp      |  24 +--
 .../regexp/properties/RegExpEmptyTest.cpp     |   4 +-
 .../regexp/properties/RegExpEpsilonTest.cpp   |  14 +-
 .../regexp/simplify/RegExpOptimizeTest.cpp    |  18 +-
 .../test-src/regexp/toAutomaton/re2faTest.cpp |  12 +-
 .../transform/RegExpConcatenateTest.cpp       |  14 +-
 .../regexp/transform/RegExpDerivationTest.cpp |   8 +-
 .../regexp/transform/RegExpIntegralTest.cpp   |   5 +-
 alib2common/src/factory/XmlDataFactory.hpp    | 168 +++++++++++-------
 .../test-src/container/ContainerTest.cpp      |  22 +--
 alib2common/test-src/object/AnyObjectTest.cpp |   2 +-
 .../test-src/primitive/PrimitiveTest.cpp      |   4 +-
 alib2data/test-src/alphabet/SymbolTest.cpp    |   4 +-
 .../automaton/AutomatonTemplatesTest.cpp      |   4 +-
 .../test-src/automaton/AutomatonTest.cpp      |   4 +-
 .../test-src/common/SparseBoolVectorTest.cpp  |   2 +-
 alib2data/test-src/grammar/GrammarTest.cpp    |  22 +--
 alib2data/test-src/label/LabelTest.cpp        |   4 +-
 alib2data/test-src/regexp/RegExpTest.cpp      |   4 +-
 alib2data/test-src/rte/RTETest.cpp            |   4 +-
 alib2data/test-src/string/StringTest.cpp      |   4 +-
 alib2data/test-src/tree/PatternTest.cpp       |   8 +-
 alib2data/test-src/tree/TreeTest.cpp          |   6 +-
 .../test-src/graph/GraphTest.cpp              |   8 +-
 alib2str/src/factory/StringDataFactory.hpp    |  77 +++++---
 alib2str/test-src/automaton/AutomatonTest.cpp |  16 +-
 alib2str/test-src/grammar/GrammarTest.cpp     |  16 +-
 alib2str/test-src/object/LabelTest.cpp        |  16 +-
 alib2str/test-src/object/ObjectTest.cpp       |   2 +-
 alib2str/test-src/object/SymbolTest.cpp       |   8 +-
 alib2str/test-src/regexp/RegExpTest.cpp       |  12 +-
 alib2str/test-src/string/StringTest.cpp       |  12 +-
 alib2str/test-src/tree/TreeTest.cpp           |  24 +--
 .../test-src/graph/GraphTest.cpp              |   8 +-
 aminimize2/src/aminimize.cpp                  |   2 +-
 anormalize2/src/anormalize.cpp                |  18 +-
 aquery2/src/aquery.cpp                        |  28 +--
 arand2/src/arand.cpp                          |   6 +-
 araw2/src/araw.cpp                            |   4 +-
 arename2/src/arename.cpp                      |   4 +-
 areverse2/src/areverse.cpp                    |   2 +-
 arun2/src/arun.cpp                            |   6 +-
 astat2/src/astat.cpp                          |   2 +-
 astringology2/src/astringology.cpp            |  58 +++---
 atrim2/src/atrim.cpp                          |   6 +-
 tniceprint/src/tniceprint.cpp                 |   4 +-
 61 files changed, 466 insertions(+), 394 deletions(-)

diff --git a/aaccess2/src/aaccess.cpp b/aaccess2/src/aaccess.cpp
index 68a48dc23b..d19cb9890c 100644
--- a/aaccess2/src/aaccess.cpp
+++ b/aaccess2/src/aaccess.cpp
@@ -153,49 +153,49 @@ int main ( int argc, char * argv[] ) {
 			argumentTokens = sax::FromXMLParserHelper::parseInput( argument );
 
 		if ( alib::XmlDataFactory::first < automaton::Automaton > ( tokens ) && automatonInput.isSet ( ) ) {
-			automaton::Automaton automaton = alib::XmlDataFactory::fromTokens < automaton::Automaton > ( std::move ( tokens ) );
+			automaton::Automaton automaton = alib::XmlDataFactory::fromTokens ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Accesss print", measurements::Type::MAIN );
 
 			AutomatonAccess::access ( automaton, AutomatonSettings::fromString ( automatonInput.getValue ( ) ), OperationSettings::fromString ( operation.getValue ( ) ), argumentTokens );
 		} else if ( alib::XmlDataFactory::first < grammar::Grammar > ( tokens ) && grammarInput.isSet ( ) ) {
-			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens < grammar::Grammar > ( std::move ( tokens ) );
+			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Accesss print", measurements::Type::MAIN );
 
 			GrammarAccess::access ( grammar, GrammarSettings::fromString ( grammarInput.getValue ( ) ), OperationSettings::fromString ( operation.getValue ( ) ), argumentTokens );
 		} else if ( alib::XmlDataFactory::first < regexp::RegExp > ( tokens ) && regexpInput.isSet ( ) ) {
-			regexp::RegExp regexp = alib::XmlDataFactory::fromTokens < regexp::RegExp > ( std::move ( tokens ) );
+			regexp::RegExp regexp = alib::XmlDataFactory::fromTokens ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Accesss print", measurements::Type::MAIN );
 
 			RegExpAccess::access ( regexp, RegExpSettings::fromString ( regexpInput.getValue ( ) ), OperationSettings::fromString ( operation.getValue ( ) ), argumentTokens );
 		} else if ( alib::XmlDataFactory::first < exception::CommonException > ( tokens ) && exceptionInput.isSet ( ) ) {
-			exception::CommonException exception = alib::XmlDataFactory::fromTokens < exception::CommonException > ( std::move ( tokens ) );
+			exception::CommonException exception = alib::XmlDataFactory::fromTokens ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Accesss print", measurements::Type::MAIN );
 
 			ExceptionAccess::access ( exception, ExceptionSettings::fromString ( exceptionInput.getValue ( ) ), OperationSettings::fromString ( operation.getValue ( ) ) );
 		} else if ( alib::XmlDataFactory::first < string::String > ( tokens ) && stringInput.isSet ( ) ) {
-			string::String string = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( tokens ) );
+			string::String string = alib::XmlDataFactory::fromTokens ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Accesss print", measurements::Type::MAIN );
 
 			StringAccess::access ( string, StringSettings::fromString ( stringInput.getValue ( ) ), OperationSettings::fromString ( operation.getValue ( ) ), argumentTokens );
 		} else if ( alib::XmlDataFactory::first < tree::Tree > ( tokens ) && treeInput.isSet ( ) ) {
-			tree::Tree tree = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( tokens ) );
+			tree::Tree tree = alib::XmlDataFactory::fromTokens ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Accesss print", measurements::Type::MAIN );
 
 			TreeAccess::access ( tree, TreeSettings::fromString ( treeInput.getValue ( ) ), OperationSettings::fromString ( operation.getValue ( ) ), argumentTokens );
 		} else if ( alib::XmlDataFactory::first < std::set < std::pair < alib::Object, alib::Object > > > ( tokens ) && pairSetInput.isSet ( ) ) {
-			std::set < std::pair < alib::Object, alib::Object > > pairSet = alib::XmlDataFactory::fromTokens < std::set < std::pair < alib::Object, alib::Object > > > ( std::move ( tokens ) );
+			std::set < std::pair < alib::Object, alib::Object > > pairSet = alib::XmlDataFactory::fromTokens ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Accesss print", measurements::Type::MAIN );
diff --git a/aaccess2/src/common/AccessHelpers.hpp b/aaccess2/src/common/AccessHelpers.hpp
index c3abd699e2..373bc282b2 100644
--- a/aaccess2/src/common/AccessHelpers.hpp
+++ b/aaccess2/src/common/AccessHelpers.hpp
@@ -17,7 +17,7 @@ void handleElement ( DataType & data, const OperationSettings::Settings & operat
 	}
 
 	if ( operation == OperationSettings::Settings::SET ) {
-		ElementDataType symbols = alib::XmlDataFactory::fromTokens < ElementDataType > ( std::move ( argument ) );
+		ElementDataType symbols = alib::XmlDataFactory::fromTokens ( std::move ( argument ) );
 
 		data.template accessElement < Element > ( ).set ( std::move ( symbols ) );
 
@@ -37,7 +37,7 @@ void handleComponent ( DataType & data, const OperationSettings::Settings & oper
 	}
 
 	if ( operation == OperationSettings::Settings::ADD ) {
-		ComponentDataType symbols = alib::XmlDataFactory::fromTokens < ComponentDataType > ( std::move ( argument ) );
+		ComponentDataType symbols = alib::XmlDataFactory::fromTokens ( std::move ( argument ) );
 
 		data.template accessComponent < Component > ( ).add ( std::move ( symbols ) );
 
@@ -45,7 +45,7 @@ void handleComponent ( DataType & data, const OperationSettings::Settings & oper
 	}
 
 	if ( operation == OperationSettings::Settings::SET ) {
-		ComponentDataType symbols = alib::XmlDataFactory::fromTokens < ComponentDataType > ( std::move ( argument ) );
+		ComponentDataType symbols = alib::XmlDataFactory::fromTokens ( std::move ( argument ) );
 
 		data.template accessComponent < Component > ( ).set ( std::move ( symbols ) );
 
@@ -53,7 +53,7 @@ void handleComponent ( DataType & data, const OperationSettings::Settings & oper
 	}
 
 	if ( operation == OperationSettings::Settings::REMOVE ) {
-		ComponentDataType symbols = alib::XmlDataFactory::fromTokens < ComponentDataType > ( std::move ( argument ) );
+		ComponentDataType symbols = alib::XmlDataFactory::fromTokens ( std::move ( argument ) );
 
 		data.template accessComponent < Component > ( ).remove ( std::move ( symbols ) );
 
diff --git a/aarbology2/src/aarbology.cpp b/aarbology2/src/aarbology.cpp
index ee3adfd876..84f6f7bea4 100644
--- a/aarbology2/src/aarbology.cpp
+++ b/aarbology2/src/aarbology.cpp
@@ -93,8 +93,8 @@ int main ( int argc, char * argv[] ) {
 		measurements::start ( "Input read", measurements::Type::AUXILIARY );
 
 		if ( algorithm.getValue ( ) == "exactSubtreeMatch" ) {
-			tree::Tree subject = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
-			tree::Tree pattern = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
+			tree::Tree subject = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			tree::Tree pattern = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -108,8 +108,8 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( algorithm.getValue ( ) == "exactPatternMatch" ) {
-			tree::Tree subject = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
-			tree::Tree pattern = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
+			tree::Tree subject = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			tree::Tree pattern = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -123,8 +123,8 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( algorithm.getValue ( ) == "boyerMooreHorspool" ) {
-			tree::Tree subject = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
-			tree::Tree pattern = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
+			tree::Tree subject = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			tree::Tree pattern = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -138,8 +138,8 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( algorithm.getValue ( ) == "reversedBoyerMooreHorspool" ) {
-			tree::Tree subject = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
-			tree::Tree pattern = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
+			tree::Tree subject = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			tree::Tree pattern = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -153,8 +153,8 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( algorithm.getValue ( ) == "knuthMorrisPratt" ) {
-			tree::Tree subject = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
-			tree::Tree pattern = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
+			tree::Tree subject = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			tree::Tree pattern = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -168,8 +168,8 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( algorithm.getValue ( ) == "deadZoneUsingBadCharacterShiftAndBorderArray" ) {
-			tree::Tree subject = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
-			tree::Tree pattern = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
+			tree::Tree subject = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			tree::Tree pattern = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -183,7 +183,7 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( algorithm.getValue ( ) == "exactSubtreeMatchingAutomaton" ) {
-			tree::Tree pattern = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
+			tree::Tree pattern = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -195,7 +195,7 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( algorithm.getValue ( ) == "exactPatternMatchingAutomaton" ) {
-			tree::Tree pattern = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
+			tree::Tree pattern = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -207,7 +207,7 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( algorithm.getValue ( ) == "exactSubtreeAutomaton" ) {
-			tree::Tree subject = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			tree::Tree subject = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -219,8 +219,8 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( algorithm.getValue ( ) == "exactTreePatternAutomaton" ) {
-			tree::Tree subject = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
-			DefaultSymbolType subtreeWildcard = alib::XmlDataFactory::fromTokens < DefaultSymbolType > ( sax::FromXMLParserHelper::parseInput(subtreeWildcardInput) );
+			tree::Tree subject = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			DefaultSymbolType subtreeWildcard = alib::XmlDataFactory::fromTokens ( sax::FromXMLParserHelper::parseInput(subtreeWildcardInput) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -232,9 +232,9 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( algorithm.getValue ( ) == "exactNonlinearTreePatternAutomaton" ) {
-			tree::Tree subject = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
-			DefaultSymbolType subtreeWildcard = alib::XmlDataFactory::fromTokens < DefaultSymbolType > ( sax::FromXMLParserHelper::parseInput(subtreeWildcardInput) );
-			std::set < DefaultSymbolType > nonlinearVariables = alib::XmlDataFactory::fromTokens < std::set < DefaultSymbolType > > ( sax::FromXMLParserHelper::parseInput(nonlinearVariablesInput) );
+			tree::Tree subject = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			DefaultSymbolType subtreeWildcard = alib::XmlDataFactory::fromTokens ( sax::FromXMLParserHelper::parseInput(subtreeWildcardInput) );
+			std::set < DefaultSymbolType > nonlinearVariables = alib::XmlDataFactory::fromTokens ( sax::FromXMLParserHelper::parseInput(nonlinearVariablesInput) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -246,7 +246,7 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( algorithm.getValue ( ) == "exactSubtreeRepeatsNaive" ) {
-			tree::Tree subject = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			tree::Tree subject = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -258,7 +258,7 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( algorithm.getValue ( ) == "compressedBitParallelIndex" ) {
-			tree::RankedTreeWrapper subject = alib::XmlDataFactory::fromTokens < tree::RankedTreeWrapper > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			tree::RankedTreeWrapper subject = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -270,7 +270,7 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( compressedBitParallelIndex );
 		} else if ( algorithm.getValue ( ) == "fullAndLinearIndex" ) {
-			tree::RankedTreeWrapper subject = alib::XmlDataFactory::fromTokens < tree::RankedTreeWrapper > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			tree::RankedTreeWrapper subject = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
diff --git a/acast2/src/acast.cpp b/acast2/src/acast.cpp
index a83df0274d..5ce6a1ff4c 100644
--- a/acast2/src/acast.cpp
+++ b/acast2/src/acast.cpp
@@ -46,7 +46,7 @@ int main(int argc, char** argv) {
 		measurements::start("Overal", measurements::Type::OVERALL);
 		measurements::start("Input read", measurements::Type::AUXILIARY);
 
-		alib::Object in = alib::XmlDataFactory::fromTokens<alib::Object>(sax::FromXMLParserHelper::parseInput(input));
+		alib::Object in = alib::XmlDataFactory::fromTokens (sax::FromXMLParserHelper::parseInput(input));
 
 		measurements::end();
 		measurements::start("Cast", measurements::Type::MAIN);
diff --git a/acompaction2/src/acompaction.cpp b/acompaction2/src/acompaction.cpp
index 3678758241..5caa4eed45 100644
--- a/acompaction2/src/acompaction.cpp
+++ b/acompaction2/src/acompaction.cpp
@@ -40,7 +40,7 @@ int main(int argc, char** argv) {
 		measurements::start("Overal", measurements::Type::OVERALL);
 		measurements::start("Input read", measurements::Type::AUXILIARY);
 
-		automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(sax::FromXMLParserHelper::parseInput(input));
+		automaton::Automaton automaton = alib::XmlDataFactory::fromTokens (sax::FromXMLParserHelper::parseInput(input));
 
 		measurements::end();
 		measurements::start("Algorithm", measurements::Type::MAIN);
diff --git a/acompare2/src/acompare.cpp b/acompare2/src/acompare.cpp
index 117b919781..16cf4db6e8 100644
--- a/acompare2/src/acompare.cpp
+++ b/acompare2/src/acompare.cpp
@@ -51,16 +51,16 @@ int main(int argc, char** argv) {
 		int res;
 
 		if(alib::XmlDataFactory::first<automaton::Automaton>(tokens1) && alib::XmlDataFactory::first<automaton::Automaton>(tokens2)) {
-			automaton::Automaton automaton1 = alib::XmlDataFactory::fromTokens<automaton::Automaton>(std::move(tokens1));
-			automaton::Automaton automaton2 = alib::XmlDataFactory::fromTokens<automaton::Automaton>(std::move(tokens2));
+			automaton::Automaton automaton1 = alib::XmlDataFactory::fromTokens (std::move(tokens1));
+			automaton::Automaton automaton2 = alib::XmlDataFactory::fromTokens (std::move(tokens2));
 
 			measurements::end();
 			measurements::start("Compare", measurements::Type::MAIN);
 
 			res = AutomatonCompare::compare(automaton1, automaton2);
 		} else if(alib::XmlDataFactory::first<grammar::Grammar>(tokens1) && alib::XmlDataFactory::first<grammar::Grammar>(tokens2)) {
-			grammar::Grammar grammar1 = alib::XmlDataFactory::fromTokens<grammar::Grammar>(std::move(tokens1));
-			grammar::Grammar grammar2 = alib::XmlDataFactory::fromTokens<grammar::Grammar>(std::move(tokens2));
+			grammar::Grammar grammar1 = alib::XmlDataFactory::fromTokens (std::move(tokens1));
+			grammar::Grammar grammar2 = alib::XmlDataFactory::fromTokens (std::move(tokens2));
 
 			measurements::end();
 			measurements::start("Compare", measurements::Type::MAIN);
diff --git a/aconversions2/src/ConversionHandler.cpp b/aconversions2/src/ConversionHandler.cpp
index be15b5c644..243d6b8e27 100644
--- a/aconversions2/src/ConversionHandler.cpp
+++ b/aconversions2/src/ConversionHandler.cpp
@@ -104,7 +104,7 @@ void ConversionHandler::convertRTE ( void ) {
 // ----------------------------------------------------------------------------
 
 void ConversionHandler::convertFAtoRE ( void ) {
-	const automaton::Automaton automaton = alib::XmlDataFactory::fromTokens < automaton::Automaton > ( std::move ( m_tokens ) );
+	const automaton::Automaton automaton = alib::XmlDataFactory::fromTokens ( std::move ( m_tokens ) );
 
 	measurements::end ( );
 	measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -137,7 +137,7 @@ void ConversionHandler::convertFAtoRE ( void ) {
 }
 
 void ConversionHandler::convertFAtoRG ( void ) {
-	const automaton::Automaton fsm = alib::XmlDataFactory::fromTokens < automaton::Automaton > ( std::move ( m_tokens ) );
+	const automaton::Automaton fsm = alib::XmlDataFactory::fromTokens ( std::move ( m_tokens ) );
 
 	measurements::end ( );
 	measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -172,7 +172,7 @@ void ConversionHandler::convertFAtoRG ( void ) {
 // ----------------------------------------------------------------------------
 
 void ConversionHandler::convertREtoFA ( void ) {
-	const regexp::RegExp regexp = alib::XmlDataFactory::fromTokens < regexp::RegExp > ( std::move ( m_tokens ) );
+	const regexp::RegExp regexp = alib::XmlDataFactory::fromTokens ( std::move ( m_tokens ) );
 
 	measurements::end ( );
 	measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -215,7 +215,7 @@ void ConversionHandler::convertREtoFA ( void ) {
 }
 
 void ConversionHandler::convertREtoRG ( void ) {
-	const regexp::RegExp regexp = alib::XmlDataFactory::fromTokens < regexp::RegExp > ( std::move ( m_tokens ) );
+	const regexp::RegExp regexp = alib::XmlDataFactory::fromTokens ( std::move ( m_tokens ) );
 
 	measurements::end ( );
 	measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -250,7 +250,7 @@ void ConversionHandler::convertREtoRG ( void ) {
 // ----------------------------------------------------------------------------
 
 void ConversionHandler::convertRGtoFA( void ) {
-	const grammar::Grammar grammar = alib::XmlDataFactory::fromTokens<grammar::Grammar>(std::move(m_tokens));
+	const grammar::Grammar grammar = alib::XmlDataFactory::fromTokens (std::move(m_tokens));
 
 	measurements::end ( );
 	measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -272,7 +272,7 @@ void ConversionHandler::convertRGtoFA( void ) {
 }
 
 void ConversionHandler::convertRGtoRE ( void ) {
-	const grammar::Grammar grammar = alib::XmlDataFactory::fromTokens < grammar::Grammar > ( std::move ( m_tokens ) );
+	const grammar::Grammar grammar = alib::XmlDataFactory::fromTokens ( std::move ( m_tokens ) );
 
 	measurements::end ( );
 	measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -295,7 +295,7 @@ void ConversionHandler::convertRGtoRE ( void ) {
 }
 
 void ConversionHandler::convertCFGtoPDA ( void ) {
-	const grammar::Grammar grammar = alib::XmlDataFactory::fromTokens < grammar::Grammar > ( std::move ( m_tokens ) );
+	const grammar::Grammar grammar = alib::XmlDataFactory::fromTokens ( std::move ( m_tokens ) );
 
 	measurements::end ( );
 	measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -327,7 +327,7 @@ void ConversionHandler::convertCFGtoPDA ( void ) {
 }
 
 void ConversionHandler::convertRTEtoPDA ( void ) {
-	const rte::RTE rte = alib::XmlDataFactory::fromTokens < rte::RTE > ( std::move ( m_tokens ) );
+	const rte::RTE rte = alib::XmlDataFactory::fromTokens ( std::move ( m_tokens ) );
 
 	measurements::end ( );
 	measurements::start ( "Algorithm", measurements::Type::MAIN );
diff --git a/aconvert2/src/aconvert.cpp b/aconvert2/src/aconvert.cpp
index 0f6d32afcb..3d186bca64 100644
--- a/aconvert2/src/aconvert.cpp
+++ b/aconvert2/src/aconvert.cpp
@@ -25,7 +25,7 @@
 #include <string/String.h>
 
 void automatonFromString ( std::istream & in, std::ostream & out ) {
-	automaton::Automaton automaton = alib::StringDataFactory::fromStream < automaton::Automaton > ( in );
+	automaton::Automaton automaton = alib::StringDataFactory::fromStream ( in );
 
 	measurements::end ( );
 	measurements::start ( "Output write", measurements::Type::AUXILIARY );
@@ -34,7 +34,7 @@ void automatonFromString ( std::istream & in, std::ostream & out ) {
 }
 
 void grammarFromString ( std::istream & in, std::ostream & out ) {
-	grammar::Grammar grammar = alib::StringDataFactory::fromStream < grammar::Grammar > ( in );
+	grammar::Grammar grammar = alib::StringDataFactory::fromStream ( in );
 
 	measurements::end ( );
 	measurements::start ( "Output write", measurements::Type::AUXILIARY );
@@ -43,7 +43,7 @@ void grammarFromString ( std::istream & in, std::ostream & out ) {
 }
 
 void regexpFromString ( std::istream & in, std::ostream & out ) {
-	regexp::RegExp regexp = alib::StringDataFactory::fromStream < regexp::RegExp > ( in );
+	regexp::RegExp regexp = alib::StringDataFactory::fromStream ( in );
 
 	measurements::end ( );
 	measurements::start ( "Output write", measurements::Type::AUXILIARY );
@@ -52,7 +52,7 @@ void regexpFromString ( std::istream & in, std::ostream & out ) {
 }
 
 void stringFromString ( std::istream & in, std::ostream & out ) {
-	string::String string = alib::StringDataFactory::fromStream < string::String > ( in );
+	string::String string = alib::StringDataFactory::fromStream ( in );
 
 	measurements::end ( );
 	measurements::start ( "Output write", measurements::Type::AUXILIARY );
@@ -61,7 +61,7 @@ void stringFromString ( std::istream & in, std::ostream & out ) {
 }
 
 void treeFromString ( std::istream & in, std::ostream & out ) {
-	tree::Tree tree = alib::StringDataFactory::fromStream < tree::Tree > ( in );
+	tree::Tree tree = alib::StringDataFactory::fromStream ( in );
 
 	measurements::end ( );
 	measurements::start ( "Output write", measurements::Type::AUXILIARY );
@@ -70,7 +70,7 @@ void treeFromString ( std::istream & in, std::ostream & out ) {
 }
 
 void automatonToString ( std::istream & in, std::ostream & out ) {
-	automaton::Automaton automaton = alib::XmlDataFactory::fromStream < automaton::Automaton > ( in );
+	automaton::Automaton automaton = alib::XmlDataFactory::fromStream ( in );
 
 	measurements::end ( );
 	measurements::start ( "Output write", measurements::Type::AUXILIARY );
@@ -79,7 +79,7 @@ void automatonToString ( std::istream & in, std::ostream & out ) {
 }
 
 void grammarToString ( std::istream & in, std::ostream & out ) {
-	grammar::Grammar grammar = alib::XmlDataFactory::fromStream < grammar::Grammar > ( in );
+	grammar::Grammar grammar = alib::XmlDataFactory::fromStream ( in );
 
 	measurements::end ( );
 	measurements::start ( "Output write", measurements::Type::AUXILIARY );
@@ -88,7 +88,7 @@ void grammarToString ( std::istream & in, std::ostream & out ) {
 }
 
 void regexpToString ( std::istream & in, std::ostream & out ) {
-	regexp::RegExp regexp = alib::XmlDataFactory::fromStream < regexp::RegExp > ( in );
+	regexp::RegExp regexp = alib::XmlDataFactory::fromStream ( in );
 
 	measurements::end ( );
 	measurements::start ( "Output write", measurements::Type::AUXILIARY );
@@ -97,7 +97,7 @@ void regexpToString ( std::istream & in, std::ostream & out ) {
 }
 
 void stringToString ( std::istream & in, std::ostream & out ) {
-	string::String string = alib::XmlDataFactory::fromStream < string::String > ( in );
+	string::String string = alib::XmlDataFactory::fromStream ( in );
 
 	measurements::end ( );
 	measurements::start ( "Output write", measurements::Type::AUXILIARY );
@@ -106,7 +106,7 @@ void stringToString ( std::istream & in, std::ostream & out ) {
 }
 
 void treeToString ( std::istream & in, std::ostream & out ) {
-	tree::Tree tree = alib::XmlDataFactory::fromStream < tree::Tree > ( in );
+	tree::Tree tree = alib::XmlDataFactory::fromStream ( in );
 
 	measurements::end ( );
 	measurements::start ( "Output write", measurements::Type::AUXILIARY );
@@ -115,7 +115,7 @@ void treeToString ( std::istream & in, std::ostream & out ) {
 }
 
 void automatonToDot ( std::istream & in, std::ostream & out ) {
-	automaton::Automaton automaton = alib::XmlDataFactory::fromStream < automaton::Automaton > ( in );
+	automaton::Automaton automaton = alib::XmlDataFactory::fromStream ( in );
 
 	measurements::end ( );
 	measurements::start ( "Output write", measurements::Type::AUXILIARY );
@@ -124,7 +124,7 @@ void automatonToDot ( std::istream & in, std::ostream & out ) {
 }
 
 void automatonToGasTex ( std::istream & in, std::ostream & out ) {
-	automaton::Automaton automaton = alib::XmlDataFactory::fromStream < automaton::Automaton > ( in );
+	automaton::Automaton automaton = alib::XmlDataFactory::fromStream ( in );
 
 	measurements::end ( );
 	measurements::start ( "Output write", measurements::Type::AUXILIARY );
@@ -133,7 +133,7 @@ void automatonToGasTex ( std::istream & in, std::ostream & out ) {
 }
 
 void automatonToTikZ ( std::istream & in, std::ostream & out ) {
-	automaton::Automaton automaton = alib::XmlDataFactory::fromStream < automaton::Automaton > ( in );
+	automaton::Automaton automaton = alib::XmlDataFactory::fromStream ( in );
 
 	measurements::end ( );
 	measurements::start ( "Output write", measurements::Type::AUXILIARY );
diff --git a/aderivation2/src/aderivation.cpp b/aderivation2/src/aderivation.cpp
index 2b3aa2f478..a8cde56f70 100644
--- a/aderivation2/src/aderivation.cpp
+++ b/aderivation2/src/aderivation.cpp
@@ -43,8 +43,8 @@ int main(int argc, char** argv) {
 		measurements::start("Overal", measurements::Type::OVERALL);
 		measurements::start("Input read", measurements::Type::AUXILIARY);
 
-		string::LinearString < > stringData = alib::XmlDataFactory::fromTokens<string::LinearString < >>(sax::FromXMLParserHelper::parseInput(string));
-		regexp::RegExp regexpData = alib::XmlDataFactory::fromTokens<regexp::RegExp>(sax::FromXMLParserHelper::parseInput(regexp));
+		string::LinearString < > stringData = alib::XmlDataFactory::fromTokens (sax::FromXMLParserHelper::parseInput(string));
+		regexp::RegExp regexpData = alib::XmlDataFactory::fromTokens (sax::FromXMLParserHelper::parseInput(regexp));
 
 		measurements::end();
 		measurements::start("Algorithm", measurements::Type::MAIN);
diff --git a/adeterminize2/src/adeterminize.cpp b/adeterminize2/src/adeterminize.cpp
index c76462d486..f48b8d6db8 100644
--- a/adeterminize2/src/adeterminize.cpp
+++ b/adeterminize2/src/adeterminize.cpp
@@ -41,7 +41,7 @@ int main(int argc, char** argv) {
 		measurements::start("Overal", measurements::Type::OVERALL);
 		measurements::start("Input read", measurements::Type::AUXILIARY);
 
-		automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(sax::FromXMLParserHelper::parseInput(input));
+		automaton::Automaton automaton = alib::XmlDataFactory::fromTokens (sax::FromXMLParserHelper::parseInput(input));
 
 		measurements::end();
 		measurements::start("Algorithm", measurements::Type::MAIN);
diff --git a/aecho2/src/aecho.cpp b/aecho2/src/aecho.cpp
index cc35aaeccd..8b01989f59 100644
--- a/aecho2/src/aecho.cpp
+++ b/aecho2/src/aecho.cpp
@@ -45,7 +45,7 @@ int main(int argc, char** argv) {
 		measurements::start("Overal", measurements::Type::OVERALL);
 		measurements::start("Input read", measurements::Type::AUXILIARY);
 
-		alib::Object object = alib::XmlDataFactory::fromTokens<alib::Object>(sax::FromXMLParserHelper::parseInput(input));
+		alib::Object object = alib::XmlDataFactory::fromTokens (sax::FromXMLParserHelper::parseInput(input));
 
 		measurements::end();
 		measurements::start("Output write", measurements::Type::AUXILIARY);
diff --git a/aepsilon2/src/aepsilon.cpp b/aepsilon2/src/aepsilon.cpp
index 1df0e3c8cc..d465c5b5f5 100644
--- a/aepsilon2/src/aepsilon.cpp
+++ b/aepsilon2/src/aepsilon.cpp
@@ -56,7 +56,7 @@ int main(int argc, char** argv) {
 		std::deque<sax::Token> tokens = sax::FromXMLParserHelper::parseInput(input);
 
 		if(algorithm.getValue() == "outgoing") {
-			automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(std::move(tokens));
+			automaton::Automaton automaton = alib::XmlDataFactory::fromTokens (std::move(tokens));
 
 			measurements::end();
 			measurements::start("Algorithm", measurements::Type::MAIN);
@@ -77,7 +77,7 @@ int main(int argc, char** argv) {
 				alib::XmlDataFactory::toStdout(res);
 			}
 		} else if(algorithm.getValue() == "incoming") {
-			automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(std::move(tokens));
+			automaton::Automaton automaton = alib::XmlDataFactory::fromTokens (std::move(tokens));
 
 			measurements::end();
 			measurements::start("Algorithm", measurements::Type::MAIN);
@@ -99,7 +99,7 @@ int main(int argc, char** argv) {
 			}
 		} else if(algorithm.getValue() == "default") {
 			if(alib::XmlDataFactory::first<automaton::Automaton>(tokens)) {
-				automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(std::move(tokens));
+				automaton::Automaton automaton = alib::XmlDataFactory::fromTokens (std::move(tokens));
 
 				measurements::end();
 				measurements::start("Algorithm", measurements::Type::MAIN);
@@ -120,7 +120,7 @@ int main(int argc, char** argv) {
 					alib::XmlDataFactory::toStdout(res);
 				}
 			} else if(alib::XmlDataFactory::first<grammar::Grammar>(tokens)) {
-				grammar::Grammar grammar = alib::XmlDataFactory::fromTokens<grammar::Grammar>(std::move(tokens));
+				grammar::Grammar grammar = alib::XmlDataFactory::fromTokens (std::move(tokens));
 
 				measurements::end();
 				measurements::start("Algorithm", measurements::Type::MAIN);
diff --git a/agenerate2/src/agenerate.cpp b/agenerate2/src/agenerate.cpp
index cc0243a7b8..93913c187c 100644
--- a/agenerate2/src/agenerate.cpp
+++ b/agenerate2/src/agenerate.cpp
@@ -62,7 +62,7 @@ int main ( int argc, char * argv[] ) {
 		measurements::start ( "Input read", measurements::Type::AUXILIARY );
 
 		if ( ( type.getValue ( ) == "upTo" ) && upto.isSet ( ) ) {
-			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens < grammar::Grammar > ( sax::FromXMLParserHelper::parseInput(grammarInput) );
+			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens ( sax::FromXMLParserHelper::parseInput(grammarInput) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -74,8 +74,8 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( type.getValue ( ) == "CYK" ) {
-			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens < grammar::Grammar > ( sax::FromXMLParserHelper::parseInput(grammarInput) );
-			string::LinearString < > string = alib::XmlDataFactory::fromTokens < string::LinearString < > > ( sax::FromXMLParserHelper::parseInput(stringInput) );
+			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens ( sax::FromXMLParserHelper::parseInput(grammarInput) );
+			string::LinearString < > string = alib::XmlDataFactory::fromTokens ( sax::FromXMLParserHelper::parseInput(stringInput) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
diff --git a/aintegral2/src/aintegral.cpp b/aintegral2/src/aintegral.cpp
index 1a394871f5..5efa84c472 100644
--- a/aintegral2/src/aintegral.cpp
+++ b/aintegral2/src/aintegral.cpp
@@ -43,8 +43,8 @@ int main(int argc, char** argv) {
 		measurements::start("Overal", measurements::Type::OVERALL);
 		measurements::start("Input read", measurements::Type::AUXILIARY);
 
-		string::LinearString < > stringData = alib::XmlDataFactory::fromTokens<string::LinearString < >>(sax::FromXMLParserHelper::parseInput(string));
-		regexp::RegExp regexpData = alib::XmlDataFactory::fromTokens<regexp::RegExp>(sax::FromXMLParserHelper::parseInput(regexp));
+		string::LinearString < > stringData = alib::XmlDataFactory::fromTokens (sax::FromXMLParserHelper::parseInput(string));
+		regexp::RegExp regexpData = alib::XmlDataFactory::fromTokens (sax::FromXMLParserHelper::parseInput(regexp));
 
 		measurements::end();
 		measurements::start("Algorithm", measurements::Type::MAIN);
diff --git a/alangop2/src/alangop.cpp b/alangop2/src/alangop.cpp
index 0e0a6d94e5..3eaaa68006 100644
--- a/alangop2/src/alangop.cpp
+++ b/alangop2/src/alangop.cpp
@@ -65,10 +65,10 @@ int main(int argc, char* argv[]) {
 		measurements::start("Overal", measurements::Type::OVERALL);
 		measurements::start("Input read", measurements::Type::AUXILIARY);
 
-		automaton::Automaton automaton1 = alib::XmlDataFactory::fromTokens<automaton::Automaton>(sax::FromXMLParserHelper::parseInput(a1));
+		automaton::Automaton automaton1 = alib::XmlDataFactory::fromTokens (sax::FromXMLParserHelper::parseInput(a1));
 
 		if( algorithm.getValue() == "unionEpsilon") {
-			automaton::Automaton automaton2 = alib::XmlDataFactory::fromTokens<automaton::Automaton>(sax::FromXMLParserHelper::parseInput(a1));
+			automaton::Automaton automaton2 = alib::XmlDataFactory::fromTokens (sax::FromXMLParserHelper::parseInput(a1));
 
 			measurements::end();
 			measurements::start("Algorithm", measurements::Type::MAIN);
@@ -81,7 +81,7 @@ int main(int argc, char* argv[]) {
 			alib::XmlDataFactory::toStdout( res );
 
 		} else if( algorithm.getValue() == "unionCartesian") {
-			automaton::Automaton automaton2 = alib::XmlDataFactory::fromTokens<automaton::Automaton>(sax::FromXMLParserHelper::parseInput(a1));
+			automaton::Automaton automaton2 = alib::XmlDataFactory::fromTokens (sax::FromXMLParserHelper::parseInput(a1));
 
 			measurements::end();
 			measurements::start("Algorithm", measurements::Type::MAIN);
@@ -93,7 +93,7 @@ int main(int argc, char* argv[]) {
 
 			alib::XmlDataFactory::toStdout( res );
 		} else if( algorithm.getValue() == "concatenationEpsilon") {
-			automaton::Automaton automaton2 = alib::XmlDataFactory::fromTokens<automaton::Automaton>(sax::FromXMLParserHelper::parseInput(a1));
+			automaton::Automaton automaton2 = alib::XmlDataFactory::fromTokens (sax::FromXMLParserHelper::parseInput(a1));
 
 			measurements::end();
 			measurements::start("Algorithm", measurements::Type::MAIN);
@@ -105,7 +105,7 @@ int main(int argc, char* argv[]) {
 
 			alib::XmlDataFactory::toStdout( res );
 		} else if( algorithm.getValue() == "concatenation") {
-			automaton::Automaton automaton2 = alib::XmlDataFactory::fromTokens<automaton::Automaton>(sax::FromXMLParserHelper::parseInput(a1));
+			automaton::Automaton automaton2 = alib::XmlDataFactory::fromTokens (sax::FromXMLParserHelper::parseInput(a1));
 
 			measurements::end();
 			measurements::start("Algorithm", measurements::Type::MAIN);
@@ -117,7 +117,7 @@ int main(int argc, char* argv[]) {
 
 			alib::XmlDataFactory::toStdout( res );
 		} else if( algorithm.getValue() == "intersectionCartesian") {
-			automaton::Automaton automaton2 = alib::XmlDataFactory::fromTokens<automaton::Automaton>(sax::FromXMLParserHelper::parseInput(a1));
+			automaton::Automaton automaton2 = alib::XmlDataFactory::fromTokens (sax::FromXMLParserHelper::parseInput(a1));
 
 			measurements::end();
 			measurements::start("Algorithm", measurements::Type::MAIN);
diff --git a/alib2algo/test-src/regexp/RegExpTest.cpp b/alib2algo/test-src/regexp/RegExpTest.cpp
index 079de0f953..4e91db594d 100644
--- a/alib2algo/test-src/regexp/RegExpTest.cpp
+++ b/alib2algo/test-src/regexp/RegExpTest.cpp
@@ -27,8 +27,8 @@ void RegExpTest::tearDown ( ) {
 void RegExpTest::testFirst ( ) {
 	{
 		std::string input = "#E* #0*";
-		regexp::UnboundedRegExp < > regexp ( static_cast < const regexp::UnboundedRegExp < > & > ( alib::StringDataFactory::fromString < regexp::RegExp > ( input ).getData ( ) ) );
-		regexp::UnboundedRegExp < std::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( regexp );
+		regexp::RegExp regexp = alib::StringDataFactory::fromString ( input );
+		regexp::UnboundedRegExp < std::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( static_cast < const regexp::UnboundedRegExp < > & > ( regexp.getData ( ) ) );
 
 		std::set < regexp::UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > > first = regexp::GlushkovFirst::first ( indexedRegExp );
 
@@ -36,8 +36,8 @@ void RegExpTest::testFirst ( ) {
 	}
 	{
 		std::string input = "#E* a";
-		regexp::UnboundedRegExp < > regexp ( static_cast < const regexp::UnboundedRegExp < > & > ( alib::StringDataFactory::fromString < regexp::RegExp > ( input ).getData ( ) ) );
-		regexp::UnboundedRegExp < std::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( regexp );
+		regexp::RegExp regexp = alib::StringDataFactory::fromString ( input );
+		regexp::UnboundedRegExp < std::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( static_cast < const regexp::UnboundedRegExp < > & > ( regexp.getData ( ) ) );
 
 		std::set < regexp::UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > > first = regexp::GlushkovFirst::first ( indexedRegExp );
 
@@ -48,8 +48,8 @@ void RegExpTest::testFirst ( ) {
 void RegExpTest::testLast ( ) {
 	{
 		std::string input = "a+a";
-		regexp::UnboundedRegExp < > regexp ( static_cast < const regexp::UnboundedRegExp < > & > ( alib::StringDataFactory::fromString < regexp::RegExp > ( input ).getData ( ) ) );
-		regexp::UnboundedRegExp < std::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( regexp );
+		regexp::RegExp regexp = alib::StringDataFactory::fromString ( input );
+		regexp::UnboundedRegExp < std::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( static_cast < const regexp::UnboundedRegExp < > & > ( regexp.getData ( ) ) );
 
 		std::set < regexp::UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > > last = regexp::GlushkovLast::last ( indexedRegExp );
 
@@ -57,8 +57,8 @@ void RegExpTest::testLast ( ) {
 	}
 	{
 		std::string input = "(a+a)b";
-		regexp::UnboundedRegExp < > regexp ( static_cast < const regexp::UnboundedRegExp < > & > ( alib::StringDataFactory::fromString < regexp::RegExp > ( input ).getData ( ) ) );
-		regexp::UnboundedRegExp < std::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( regexp );
+		regexp::RegExp regexp = alib::StringDataFactory::fromString ( input );
+		regexp::UnboundedRegExp < std::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( static_cast < const regexp::UnboundedRegExp < > & > ( regexp.getData ( ) ) );
 
 		std::set < regexp::UnboundedRegExpSymbol < std::pair < DefaultSymbolType, int > > > last = regexp::GlushkovLast::last ( indexedRegExp );
 
@@ -70,8 +70,8 @@ void RegExpTest::testLast ( ) {
 void RegExpTest::testFollow ( ) {
 	{
 		std::string input = "(a+a)b";
-		regexp::UnboundedRegExp < > regexp ( static_cast < const regexp::UnboundedRegExp < > & > ( alib::StringDataFactory::fromString < regexp::RegExp > ( input ).getData ( ) ) );
-		regexp::UnboundedRegExp < std::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( regexp );
+		regexp::RegExp regexp = alib::StringDataFactory::fromString ( input );
+		regexp::UnboundedRegExp < std::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( static_cast < const regexp::UnboundedRegExp < > & > ( regexp.getData ( ) ) );
 
 		auto symbolsIter = indexedRegExp.getAlphabet ( ).begin ( );
 
@@ -91,8 +91,8 @@ void RegExpTest::testFollow ( ) {
 	}
 	{
 		std::string input = "a+a* (b+a)* c";
-		regexp::UnboundedRegExp < > regexp ( static_cast < const regexp::UnboundedRegExp < > & > ( alib::StringDataFactory::fromString < regexp::RegExp > ( input ).getData ( ) ) );
-		regexp::UnboundedRegExp < std::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( regexp );
+		regexp::RegExp regexp = alib::StringDataFactory::fromString ( input );
+		regexp::UnboundedRegExp < std::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( static_cast < const regexp::UnboundedRegExp < > & > ( regexp.getData ( ) ) );
 
 		auto symbolsIter = indexedRegExp.getAlphabet ( ).begin ( );
 
diff --git a/alib2algo/test-src/regexp/properties/RegExpEmptyTest.cpp b/alib2algo/test-src/regexp/properties/RegExpEmptyTest.cpp
index 944578d389..763deaa642 100644
--- a/alib2algo/test-src/regexp/properties/RegExpEmptyTest.cpp
+++ b/alib2algo/test-src/regexp/properties/RegExpEmptyTest.cpp
@@ -18,13 +18,13 @@ void RegExpEmptyTest::tearDown() {
 void RegExpEmptyTest::testRegExpEmpty() {
 	{
 		std::string input = "(#E #0 ) + ( #0 a + (b ( #0 (a*) ) ) )";
-		regexp::RegExp re = alib::StringDataFactory::fromString<regexp::RegExp>(input);
+		regexp::RegExp re = alib::StringDataFactory::fromString (input);
 
 		CPPUNIT_ASSERT(regexp::properties::RegExpEmpty::languageIsEmpty(re));
 	}
 	{
 		std::string input = "(#E + a ) + ( #0 a + (b ( #0 (a*) ) ) )";
-		regexp::RegExp re = alib::StringDataFactory::fromString<regexp::RegExp>(input);
+		regexp::RegExp re = alib::StringDataFactory::fromString (input);
 
 		CPPUNIT_ASSERT(! regexp::properties::RegExpEmpty::languageIsEmpty(re));
 	}
diff --git a/alib2algo/test-src/regexp/properties/RegExpEpsilonTest.cpp b/alib2algo/test-src/regexp/properties/RegExpEpsilonTest.cpp
index f1f6aa02a0..4026c0b89b 100644
--- a/alib2algo/test-src/regexp/properties/RegExpEpsilonTest.cpp
+++ b/alib2algo/test-src/regexp/properties/RegExpEpsilonTest.cpp
@@ -16,43 +16,43 @@ void RegExpEpsilonTest::tearDown() {
 void RegExpEpsilonTest::testRegExpEpsilon() {
 	{
 		std::string input = "#E + ( (a #E) + a*)";
-		regexp::RegExp re = alib::StringDataFactory::fromString<regexp::RegExp>(input);
+		regexp::RegExp re = alib::StringDataFactory::fromString (input);
 
 		CPPUNIT_ASSERT(regexp::properties::RegExpEpsilon::languageContainsEpsilon(re));
 	}
 	{
 		std::string input = "( a* )( a* )";
-		regexp::RegExp re = alib::StringDataFactory::fromString<regexp::RegExp>(input);
+		regexp::RegExp re = alib::StringDataFactory::fromString (input);
 
 		CPPUNIT_ASSERT(regexp::properties::RegExpEpsilon::languageContainsEpsilon(re));
 	}
 	{
 		std::string input = "a + #0";
-		regexp::RegExp re = alib::StringDataFactory::fromString<regexp::RegExp>(input);
+		regexp::RegExp re = alib::StringDataFactory::fromString (input);
 
 		CPPUNIT_ASSERT(! regexp::properties::RegExpEpsilon::languageContainsEpsilon(re));
 	}
 	{
 		std::string input = "#E + a #E + a*";
-		regexp::RegExp re = alib::StringDataFactory::fromString<regexp::RegExp>(input);
+		regexp::RegExp re = alib::StringDataFactory::fromString (input);
 
 		CPPUNIT_ASSERT(regexp::properties::RegExpEpsilon::languageContainsEpsilon(re));
 	}
 	{
 		std::string input = "a* a*";
-		regexp::RegExp re = alib::StringDataFactory::fromString<regexp::RegExp>(input);
+		regexp::RegExp re = alib::StringDataFactory::fromString (input);
 
 		CPPUNIT_ASSERT(regexp::properties::RegExpEpsilon::languageContainsEpsilon(re));
 	}
 	{
 		std::string input = "a s d #E + #E #0";
-		regexp::RegExp re = alib::StringDataFactory::fromString<regexp::RegExp>(input);
+		regexp::RegExp re = alib::StringDataFactory::fromString (input);
 
 		CPPUNIT_ASSERT(! regexp::properties::RegExpEpsilon::languageContainsEpsilon(re));
 	}
 	{
 		std::string input = "a + #0";
-		regexp::RegExp re = alib::StringDataFactory::fromString<regexp::RegExp>(input);
+		regexp::RegExp re = alib::StringDataFactory::fromString (input);
 
 		CPPUNIT_ASSERT(! regexp::properties::RegExpEpsilon::languageContainsEpsilon(re));
 	}
diff --git a/alib2algo/test-src/regexp/simplify/RegExpOptimizeTest.cpp b/alib2algo/test-src/regexp/simplify/RegExpOptimizeTest.cpp
index 6dbcb6d433..9bdf068614 100644
--- a/alib2algo/test-src/regexp/simplify/RegExpOptimizeTest.cpp
+++ b/alib2algo/test-src/regexp/simplify/RegExpOptimizeTest.cpp
@@ -21,12 +21,12 @@ void RegExpOptimizeTest::tearDown() {
 void RegExpOptimizeTest::testOptimize() {
 	{
 		std::string input = "a+a";
-		regexp::UnboundedRegExp < > regexp( static_cast<const regexp::UnboundedRegExp < > &>( alib::StringDataFactory::fromString<regexp::RegExp>(input).getData() ) );
+		regexp::RegExp regexp = alib::StringDataFactory::fromString ( input );
 
-		regexp::UnboundedRegExp < > res = regexp::simplify::RegExpOptimize::optimize(regexp);
+		regexp::RegExp res = regexp::simplify::RegExpOptimize::optimize ( regexp );
 
 		std::string inputRes = "a";
-		regexp::UnboundedRegExp < > regexpRes( static_cast<const regexp::UnboundedRegExp < DefaultSymbolType > &>( alib::StringDataFactory::fromString<regexp::RegExp>(inputRes).getData() ) );
+		regexp::RegExp regexpRes = alib::StringDataFactory::fromString ( inputRes );
 
 		std::cout << res << std::endl;
 		std::cout << regexpRes << std::endl;
@@ -35,12 +35,12 @@ void RegExpOptimizeTest::testOptimize() {
 	}
 	{
 		std::string input = "(a+a)b + (#0 b + (#0 a + (#0 b + a)))";
-		regexp::UnboundedRegExp < > regexp( static_cast<const regexp::UnboundedRegExp < > &>( alib::StringDataFactory::fromString<regexp::RegExp>(input).getData() ) );
+		regexp::RegExp regexp = alib::StringDataFactory::fromString ( input );
 
-		regexp::UnboundedRegExp < > res = regexp::simplify::RegExpOptimize::optimize(regexp);
+		regexp::RegExp res = regexp::simplify::RegExpOptimize::optimize ( regexp );
 
 		std::string inputRes = "a + a b";
-		regexp::UnboundedRegExp < > regexpRes( static_cast<const regexp::UnboundedRegExp < > &>( alib::StringDataFactory::fromString<regexp::RegExp>(inputRes).getData() ) );
+		regexp::RegExp regexpRes = alib::StringDataFactory::fromString ( inputRes );
 
 		std::cout << res << std::endl;
 		std::cout << regexpRes << std::endl;
@@ -49,12 +49,12 @@ void RegExpOptimizeTest::testOptimize() {
 	}
 	{
 		std::string input = "a z + a b* b z";
-		regexp::UnboundedRegExp < > regexp( static_cast<const regexp::UnboundedRegExp < > &>( alib::StringDataFactory::fromString<regexp::RegExp>(input).getData() ) );
+		regexp::RegExp regexp = alib::StringDataFactory::fromString ( input );
 
-		regexp::UnboundedRegExp < > res = regexp::simplify::RegExpOptimize::optimize(regexp);
+		regexp::RegExp res = regexp::simplify::RegExpOptimize::optimize ( regexp );
 
 		std::string inputRes = "a b* z";
-		regexp::UnboundedRegExp < > regexpRes( static_cast<const regexp::UnboundedRegExp < > &>( alib::StringDataFactory::fromString<regexp::RegExp>(inputRes).getData() ) );
+		regexp::RegExp regexpRes = alib::StringDataFactory::fromString ( inputRes );
 
 		std::cout << res << std::endl;
 		std::cout << regexpRes << std::endl;
diff --git a/alib2algo/test-src/regexp/toAutomaton/re2faTest.cpp b/alib2algo/test-src/regexp/toAutomaton/re2faTest.cpp
index f36bc16ca9..2b74ed4a24 100644
--- a/alib2algo/test-src/regexp/toAutomaton/re2faTest.cpp
+++ b/alib2algo/test-src/regexp/toAutomaton/re2faTest.cpp
@@ -26,7 +26,7 @@ void re2faTest::tearDown() {
 
 void re2faTest::testThompson() {
 	std::string input = "a+a* b*";
-	regexp::RegExp regexp1 = alib::StringDataFactory::fromString<regexp::RegExp>(input);
+	regexp::RegExp regexp1 = alib::StringDataFactory::fromString (input);
 
 	automaton::EpsilonNFA < > enfa1 = regexp::convert::ToAutomatonThompson::convert(regexp1);
 
@@ -48,16 +48,16 @@ void re2faTest::testThompson() {
 
 void re2faTest::testGlushkov() {
 	std::string input = "a+a*b*";
-	regexp::UnboundedRegExp < > regexp1( static_cast<const regexp::UnboundedRegExp < > &>( alib::StringDataFactory::fromString<regexp::RegExp>(input).getData() ) );
+	regexp::RegExp regexp1 = alib::StringDataFactory::fromString ( input );
 
-	automaton::NFA < >  nfa1 = regexp::convert::ToAutomatonGlushkov::convert(regexp1);
+	automaton::NFA < > nfa1 = regexp::convert::ToAutomatonGlushkov::convert ( regexp1 );
 
-	regexp::UnboundedRegExp < > regexp2( static_cast<const regexp::UnboundedRegExp < > &>( automaton::convert::ToRegExpAlgebraic::convert(nfa1) ) );
+	regexp::UnboundedRegExp < > regexp2 = automaton::convert::ToRegExpAlgebraic::convert ( nfa1 );
 
 	std::cout << regexp1 << std::endl;
 	std::cout << regexp2 << std::endl;
 
-	automaton::NFA < >  nfa2 = regexp::convert::ToAutomatonGlushkov::convert(regexp2);
+	automaton::NFA < > nfa2 = regexp::convert::ToAutomatonGlushkov::convert(regexp2);
 
 	automaton::DFA<> dfa1 = automaton::determinize::Determinize::determinize(nfa1);
 	automaton::DFA<> dfa2 = automaton::determinize::Determinize::determinize(nfa2);
@@ -73,7 +73,7 @@ void re2faTest::testGlushkov() {
 
 void re2faTest::testBrzozowski() {
 	std::string input = "a+a* b*";
-	regexp::RegExp regexp1 = alib::StringDataFactory::fromString<regexp::RegExp>(input);
+	regexp::RegExp regexp1 = alib::StringDataFactory::fromString (input);
 
 	automaton::DFA<> dfa1 = regexp::convert::ToAutomatonDerivation::convert(regexp1);
 
diff --git a/alib2algo/test-src/regexp/transform/RegExpConcatenateTest.cpp b/alib2algo/test-src/regexp/transform/RegExpConcatenateTest.cpp
index 0dbfd78d00..062aa592d2 100644
--- a/alib2algo/test-src/regexp/transform/RegExpConcatenateTest.cpp
+++ b/alib2algo/test-src/regexp/transform/RegExpConcatenateTest.cpp
@@ -19,28 +19,28 @@ void RegExpConcatenateTest::tearDown() {
 void RegExpConcatenateTest::testRegExpConcatenate() {
 	{
 		std::string input1 = "(#E a b)";
-		regexp::RegExp re1 = alib::StringDataFactory::fromString<regexp::RegExp>(input1);
+		regexp::RegExp re1 = alib::StringDataFactory::fromString (input1);
 
 		std::string input2 = "(#E a c)";
-		regexp::RegExp re2 = alib::StringDataFactory::fromString<regexp::RegExp>(input2);
+		regexp::RegExp re2 = alib::StringDataFactory::fromString (input2);
 
 		regexp::RegExp re = regexp::RegExpConcatenate::concatenate(re1, re2);
 
 		std::string inputr = "(#E a b)(#E a c)";
-		regexp::RegExp rer = alib::StringDataFactory::fromString<regexp::RegExp>(inputr);
+		regexp::RegExp rer = alib::StringDataFactory::fromString (inputr);
 
 		CPPUNIT_ASSERT(re == rer);
 	}
 	{
 		std::string input1 = "(#E a b)";
-		regexp::RegExp re1 = alib::StringDataFactory::fromString<regexp::RegExp>(input1);
+		regexp::RegExp re1 = alib::StringDataFactory::fromString (input1);
 
 		regexp::RegExp re2(regexp::FormalRegExp < > (regexp::FormalRegExpStructure < DefaultSymbolType > (regexp::FormalRegExpConcatenation < DefaultSymbolType > (regexp::FormalRegExpEmpty < DefaultSymbolType > {}, regexp::FormalRegExpEpsilon < DefaultSymbolType >  {}))));
 
 		regexp::RegExp re = regexp::RegExpConcatenate::concatenate(re1, re2);
 
 		std::string inputr = "(#E a b)(#0 #E )";
-		regexp::RegExp rer = alib::StringDataFactory::fromString<regexp::RegExp>(inputr);
+		regexp::RegExp rer = alib::StringDataFactory::fromString (inputr);
 
 		CPPUNIT_ASSERT(re == rer);
 	}
@@ -48,12 +48,12 @@ void RegExpConcatenateTest::testRegExpConcatenate() {
 		regexp::RegExp re1(regexp::FormalRegExp < > (regexp::FormalRegExpStructure < DefaultSymbolType > (regexp::FormalRegExpConcatenation < DefaultSymbolType > (regexp::FormalRegExpEmpty < DefaultSymbolType > {}, regexp::FormalRegExpEpsilon < DefaultSymbolType >  {}))));
 
 		std::string input2 = "(#E a b)";
-		regexp::RegExp re2 = alib::StringDataFactory::fromString<regexp::RegExp>(input2);
+		regexp::RegExp re2 = alib::StringDataFactory::fromString (input2);
 
 		regexp::RegExp re = regexp::RegExpConcatenate::concatenate(re1, re2);
 
 		std::string inputr = "(#0 #E )(#E a b)";
-		regexp::RegExp tmp = alib::StringDataFactory::fromString<regexp::RegExp>(inputr);
+		regexp::RegExp tmp = alib::StringDataFactory::fromString (inputr);
 		regexp::RegExp rer(regexp::FormalRegExp < > (dynamic_cast<const regexp::UnboundedRegExp < > & >(tmp.getData())));
 
 		std::cout << (dynamic_cast<const regexp::UnboundedRegExp < > & >(tmp.getData())).getAlphabet() << std::endl;
diff --git a/alib2algo/test-src/regexp/transform/RegExpDerivationTest.cpp b/alib2algo/test-src/regexp/transform/RegExpDerivationTest.cpp
index 196c14f412..02eaa75d1c 100644
--- a/alib2algo/test-src/regexp/transform/RegExpDerivationTest.cpp
+++ b/alib2algo/test-src/regexp/transform/RegExpDerivationTest.cpp
@@ -31,13 +31,13 @@ void RegExpDerivationTest::testRegExpDerivation() {
 }
 
 void RegExpDerivationTest::ExecSingleTest(std::string regexp_str, std::string string_str, std::string result) {
-    regexp::RegExp regexp0 = alib::StringDataFactory::fromString<regexp::RegExp>(regexp_str);
+    regexp::RegExp regexp0 = alib::StringDataFactory::fromString (regexp_str);
     std::deque<sax::Token> tokens = alib::XmlDataFactory::toTokens(regexp0);
-    regexp::RegExp regexp = alib::XmlDataFactory::fromTokens<regexp::RegExp>(std::move(tokens));
+    regexp::RegExp regexp = alib::XmlDataFactory::fromTokens (std::move(tokens));
 
-    string::String string0 = alib::StringDataFactory::fromString<string::String>("\"" + string_str + "\"");
+    string::String string0 = alib::StringDataFactory::fromString ("\"" + string_str + "\"");
     std::deque<sax::Token> tokens2 = alib::XmlDataFactory::toTokens(string0);
-    string::String string1 = alib::XmlDataFactory::fromTokens<string::String>(std::move(tokens2));
+    string::String string1 = alib::XmlDataFactory::fromTokens (std::move(tokens2));
 
     string::LinearString < > string = static_cast<const string::LinearString < >&>(string1.getData());
 
diff --git a/alib2algo/test-src/regexp/transform/RegExpIntegralTest.cpp b/alib2algo/test-src/regexp/transform/RegExpIntegralTest.cpp
index 2ad4d37089..b8791fa294 100644
--- a/alib2algo/test-src/regexp/transform/RegExpIntegralTest.cpp
+++ b/alib2algo/test-src/regexp/transform/RegExpIntegralTest.cpp
@@ -22,9 +22,10 @@ void RegExpIntegralTest::testRegExpIntegral() {
 }
 
 void RegExpIntegralTest::ExecSingleTest(std::string regexp_str, std::string string_str, std::string result) {
-    regexp::RegExp regexp = alib::StringDataFactory::fromString<regexp::RegExp>(regexp_str);
+    regexp::RegExp regexp = alib::StringDataFactory::fromString ( regexp_str );
+    string::String str = alib::StringDataFactory::fromString ( "\"" + string_str + "\"" );
 
-    string::LinearString < > string = static_cast<const string::LinearString < >&>(alib::StringDataFactory::fromString<string::String>("\"" + string_str + "\"").getData());
+    const string::LinearString < > & string = static_cast < const string::LinearString < > & > ( str.getData ( ) );
 
     std::cout << alib::StringDataFactory::toString<regexp::RegExp>(regexp::RegExpIntegral::integral(regexp, string)) << " == " << result << std::endl;
 
diff --git a/alib2common/src/factory/XmlDataFactory.hpp b/alib2common/src/factory/XmlDataFactory.hpp
index 65977b8b6c..c6cca1c756 100644
--- a/alib2common/src/factory/XmlDataFactory.hpp
+++ b/alib2common/src/factory/XmlDataFactory.hpp
@@ -5,8 +5,8 @@
  *      Author: Jan Travnicek
  */
 
-#ifndef DATA_FACTORY_H_
-#define DATA_FACTORY_H_
+#ifndef XML_DATA_FACTORY_HPP_
+#define XML_DATA_FACTORY_HPP_
 
 #include <string>
 #include <deque>
@@ -25,77 +25,113 @@ namespace alib {
  */
 class XmlDataFactory {
 public:
-	/**
-	 * Parses the XML in file and returns the String.
-	 * @param filename path to the file
-	 * @return String
-	 */
-	template < class T >
-	static T fromFile ( const std::string & filename ) {
-		std::deque < sax::Token > tokens;
-		sax::SaxParseInterface::parseFile ( filename, tokens );
-
-		return fromTokens < T > ( std::move( tokens ) );
-	}
-
-	/**
-	 * Parses the XML and returns the String.
-	 * @param str string containing the XML
-	 * @return String
-	 */
-	template < class T >
-	static T fromString ( const std::string & str ) {
-		std::deque < sax::Token > tokens;
-		sax::SaxParseInterface::parseMemory ( str, tokens );
-
-		return fromTokens < T > ( std::move ( tokens ) );
-	}
-
-	/**
-	 * Parses the XML from stdin and returns the String.
-	 * @return String
-	 */
-	template < class T >
-	static T fromStdin ( ) {
-		std::deque < sax::Token > tokens;
-		sax::SaxParseInterface::parseStdin ( tokens );
 
-		return fromTokens < T > ( std::move ( tokens ) );
-	}
-
-	/**
-	 * Parses the XML from stream and returns the String.
-	 * @return String
-	 */
-	template < class T >
-	static T fromStream ( std::istream & in ) {
+	class fromFile {
+		const std::string & filename;
+
+	public:
+		fromFile ( const std::string & file ) : filename ( file ) {
+		}
+
+		/**
+		 * Parses the XML in file and returns the String.
+		 * @param filename path to the file
+		 * @return String
+		 */
+		template < class T >
+		operator T ( ) {
+			std::deque < sax::Token > tokens;
+			sax::SaxParseInterface::parseFile ( filename, tokens );
+
+			return fromTokens ( std::move( tokens ) );
+		}
+	};
+
+	class fromString {
+		const std::string & string;
+
+	public:
+		fromString ( const std::string & str ) : string ( str ) {
+		}
+
+		/**
+		 * Parses the XML and returns the String.
+		 * @param str string containing the XML
+		 * @return String
+		 */
+		template < class T >
+		operator T ( ) {
+			std::deque < sax::Token > tokens;
+			sax::SaxParseInterface::parseMemory ( string, tokens );
+
+			return fromTokens ( std::move ( tokens ) );
+		}
+	};
+
+	class fromStdin {
+	public:
+		/**
+		 * Parses the XML from stdin and returns the String.
+		 * @return String
+		 */
+		template < class T >
+		operator T ( ) {
+			std::deque < sax::Token > tokens;
+			sax::SaxParseInterface::parseStdin ( tokens );
+
+			return fromTokens ( std::move ( tokens ) );
+		}
+	};
+
+	class fromStream {
+		std::istream & in;
+
+	public:
+		fromStream ( std::istream & i ) : in ( i ) {
+		}
+
+		/**
+		 * Parses the XML from stream and returns the String.
+		 * @return String
+		 */
+		template < class T >
+		operator T ( ) {
+			std::deque < sax::Token > tokens;
+			sax::SaxParseInterface::parseStream ( in, tokens );
+
+			return fromTokens ( std::move ( tokens ) );
+		}
+	};
+
+	class fromTokens {
 		std::deque < sax::Token > tokens;
-		sax::SaxParseInterface::parseStream ( in, tokens );
 
-		return fromTokens < T > ( std::move ( tokens ) );
-	}
+	public:
+		fromTokens ( std::deque < sax::Token > && toks ) : tokens ( std::move ( toks ) ) {
+		}
 
-	/**
-	 * Parses the String from list of tokens.
-	 * @param tokens XML represented as list of tokens
-	 * @return parsed String
-	 */
-	template < class T >
-	static T fromTokens ( std::deque < sax::Token > && tokens ) {
-		xmlApiInputContext context ( tokens.begin ( ) );
+		/**
+		 * Parses the String from list of tokens.
+		 * @param tokens XML represented as list of tokens
+		 * @return parsed String
+		 */
+		template < class T >
+		operator T ( ) {
+			xmlApiInputContext context ( tokens.begin ( ) );
 
-		if ( context == tokens.end ( ) ) throw exception::CommonException ( "Empty tokens list" );
+			if ( context == tokens.end ( ) ) throw exception::CommonException ( "Empty tokens list" );
 
-		if ( alib::xmlApi < exception::CommonException >::first ( context ) ) throw alib::xmlApi < exception::CommonException >::parse ( context );
+			if ( alib::xmlApi < exception::CommonException >::first ( context ) ) throw alib::xmlApi < exception::CommonException >::parse ( context );
 
-		measurements::start ( "XML Parser", measurements::Type::INIT );
-		T res = alib::xmlApi < T >::parse ( context );
-		measurements::end ( );
+			measurements::start ( "XML Parser", measurements::Type::INIT );
+			T res = alib::xmlApi < T >::parse ( context );
+			measurements::end ( );
 
-		if ( context != tokens.end ( ) ) throw exception::CommonException ( "Unexpeted tokens at the end of the xml" );
+			if ( context != tokens.end ( ) ) throw exception::CommonException ( "Unexpeted tokens at the end of the xml" );
 
-		return res;
-	}
+			return res;
+		}
+	};
 
 	/**
 	 * Determines whether the input token stream contains given type
@@ -178,7 +214,7 @@ inline bool XmlDataFactory::first < exception::CommonException > ( const std::de
 }
 
 template < >
-inline exception::CommonException XmlDataFactory::fromTokens < exception::CommonException > ( std::deque < sax::Token > && tokens ) {
+inline XmlDataFactory::fromTokens::operator exception::CommonException ( ) {
 	std::deque < sax::Token >::iterator iter = tokens.begin ( );
 
 	if ( iter == tokens.end ( ) ) throw exception::CommonException ( "Empty tokens list" );
@@ -192,4 +228,4 @@ inline exception::CommonException XmlDataFactory::fromTokens < exception::Common
 
 } /* namespace alib */
 
-#endif /* DATA_FACTORY_H_ */
+#endif /* XML_DATA_FACTORY_HPP_ */
diff --git a/alib2common/test-src/container/ContainerTest.cpp b/alib2common/test-src/container/ContainerTest.cpp
index bc4d5a142d..e996ef394a 100644
--- a/alib2common/test-src/container/ContainerTest.cpp
+++ b/alib2common/test-src/container/ContainerTest.cpp
@@ -41,16 +41,16 @@ void ContainerTest::testXMLParser ( ) {
 
 		std::cout << tmp2 << std::endl;
 
-		alib::Object object2 = alib::XmlDataFactory::fromString < alib::Object > ( tmp2 );
+		alib::Object object2 = alib::XmlDataFactory::fromString ( tmp2 );
 
 		CPPUNIT_ASSERT ( object == object2 );
 
-		std::set < primitive::String > concrete = alib::XmlDataFactory::fromString < std::set < primitive::String > > ( tmp2 );
+		std::set < primitive::String > concrete = alib::XmlDataFactory::fromString ( tmp2 );
 		std::string tmp3 = alib::XmlDataFactory::toString ( concrete );
 
 		std::cout << tmp3 << std::endl;
 
-		alib::Object object3 = alib::XmlDataFactory::fromString < alib::Object > ( tmp3 );
+		alib::Object object3 = alib::XmlDataFactory::fromString ( tmp3 );
 
 		CPPUNIT_ASSERT ( object == object3 );
 	}
@@ -59,13 +59,13 @@ void ContainerTest::testXMLParser ( ) {
 void ContainerTest::testVariantParsing ( ) {
 	{
 		std::string string = "<String>aaa</String>";
-		std::variant < int, std::string > object = alib::XmlDataFactory::fromString < std::variant < int, std::string > > ( string );
+		std::variant < int, std::string > object = alib::XmlDataFactory::fromString ( string );
 
 		CPPUNIT_ASSERT ( "aaa" == object.get < std::string > ( ) );
 
 		std::string string2 = alib::XmlDataFactory::toString ( object );
 
-		std::variant < int, std::string > object2 = alib::XmlDataFactory::fromString < std::variant < int, std::string > > ( string2 );
+		std::variant < int, std::string > object2 = alib::XmlDataFactory::fromString ( string2 );
 
 		CPPUNIT_ASSERT ( object == object2 );
 	}
@@ -78,7 +78,7 @@ void ContainerTest::testTreeParsing ( ) {
 		std::string string = alib::XmlDataFactory::toString ( t );
 		std::cout << string << std::endl;
 
-		std::tree < int > t2 = alib::XmlDataFactory::fromString < std::tree < int > > ( string );
+		std::tree < int > t2 = alib::XmlDataFactory::fromString ( string );
 
 		CPPUNIT_ASSERT ( t == t2 );
 	}
@@ -88,7 +88,7 @@ void ContainerTest::testTreeParsing ( ) {
 		std::string string = alib::XmlDataFactory::toString ( t );
 		std::cout << string << std::endl;
 
-		std::tree < int > t2 = alib::XmlDataFactory::fromString < std::tree < int > > ( string );
+		std::tree < int > t2 = alib::XmlDataFactory::fromString ( string );
 
 		CPPUNIT_ASSERT ( t == t2 );
 	}
@@ -98,7 +98,7 @@ void ContainerTest::testTreeParsing ( ) {
 		std::string string = alib::XmlDataFactory::toString ( t );
 		std::cout << string << std::endl;
 
-		std::tree < int > t2 = alib::XmlDataFactory::fromString < std::tree < int > > ( string );
+		std::tree < int > t2 = alib::XmlDataFactory::fromString ( string );
 
 		CPPUNIT_ASSERT ( t == t2 );
 	}
@@ -111,7 +111,7 @@ void ContainerTest::testTrieParsing ( ) {
 		std::string string = alib::XmlDataFactory::toString ( t );
 		std::cout << string << std::endl;
 
-		std::trie < char, int > t2 = alib::XmlDataFactory::fromString < std::trie < char, int > > ( string );
+		std::trie < char, int > t2 = alib::XmlDataFactory::fromString ( string );
 
 		CPPUNIT_ASSERT ( t == t2 );
 	}
@@ -121,7 +121,7 @@ void ContainerTest::testTrieParsing ( ) {
 		std::string string = alib::XmlDataFactory::toString ( t );
 		std::cout << string << std::endl;
 
-		std::trie < char, int > t2 = alib::XmlDataFactory::fromString < std::trie < char, int > > ( string );
+		std::trie < char, int > t2 = alib::XmlDataFactory::fromString ( string );
 
 		CPPUNIT_ASSERT ( t == t2 );
 	}
@@ -131,7 +131,7 @@ void ContainerTest::testTrieParsing ( ) {
 		std::string string = alib::XmlDataFactory::toString ( t );
 		std::cout << string << std::endl;
 
-		std::trie < char, int > t2 = alib::XmlDataFactory::fromString < std::trie < char, int > > ( string );
+		std::trie < char, int > t2 = alib::XmlDataFactory::fromString ( string );
 
 		CPPUNIT_ASSERT ( t == t2 );
 	}
diff --git a/alib2common/test-src/object/AnyObjectTest.cpp b/alib2common/test-src/object/AnyObjectTest.cpp
index df2fd7e34b..2cda69f099 100644
--- a/alib2common/test-src/object/AnyObjectTest.cpp
+++ b/alib2common/test-src/object/AnyObjectTest.cpp
@@ -26,7 +26,7 @@ void AnyObjectTest::testXMLParser ( ) {
 
 	{
 		std::string tmp = alib::XmlDataFactory::toString ( object );
-		alib::Object object2 = alib::XmlDataFactory::fromString < alib::Object > ( tmp );
+		alib::Object object2 = alib::XmlDataFactory::fromString ( tmp );
 
 		CPPUNIT_ASSERT ( res == object2 );
 	}
diff --git a/alib2common/test-src/primitive/PrimitiveTest.cpp b/alib2common/test-src/primitive/PrimitiveTest.cpp
index ab9a79279c..f1a1f132d1 100644
--- a/alib2common/test-src/primitive/PrimitiveTest.cpp
+++ b/alib2common/test-src/primitive/PrimitiveTest.cpp
@@ -31,13 +31,13 @@ void PrimitiveTest::testXMLParser() {
 
 		std::deque<sax::Token> tokens2;
 		sax::SaxParseInterface::parseMemory(tmp, tokens2);
-		primitive::Primitive primitive2 = alib::XmlDataFactory::fromTokens<primitive::Primitive>(std::move(tokens2));
+		primitive::Primitive primitive2 = alib::XmlDataFactory::fromTokens (std::move(tokens2));
 
 		CPPUNIT_ASSERT( primitive == primitive2 );
 	}
 	{
 		std::string tmp = alib::XmlDataFactory::toString(primitive);
-		primitive::Primitive primitive2 = alib::XmlDataFactory::fromString<primitive::Primitive>(tmp);
+		primitive::Primitive primitive2 = alib::XmlDataFactory::fromString (tmp);
 
 		CPPUNIT_ASSERT( primitive == primitive2 );
 	}
diff --git a/alib2data/test-src/alphabet/SymbolTest.cpp b/alib2data/test-src/alphabet/SymbolTest.cpp
index 636cdbc0f5..643e6f2e0c 100644
--- a/alib2data/test-src/alphabet/SymbolTest.cpp
+++ b/alib2data/test-src/alphabet/SymbolTest.cpp
@@ -48,13 +48,13 @@ void SymbolTest::testXMLParser ( ) {
 
 		std::deque < sax::Token > tokens2;
 		sax::SaxParseInterface::parseMemory ( tmp, tokens2 );
-		alphabet::Symbol symbol2 = alib::XmlDataFactory::fromTokens < alphabet::Symbol > ( std::move( tokens2 ) );
+		alphabet::Symbol symbol2 = alib::XmlDataFactory::fromTokens ( std::move( tokens2 ) );
 
 		CPPUNIT_ASSERT ( symbol == symbol2 );
 	}
 	{
 		std::string tmp = alib::XmlDataFactory::toString ( symbol );
-		alphabet::Symbol symbol2 = alib::XmlDataFactory::fromString < alphabet::Symbol > ( tmp );
+		alphabet::Symbol symbol2 = alib::XmlDataFactory::fromString ( tmp );
 
 		CPPUNIT_ASSERT ( symbol == symbol2 );
 	}
diff --git a/alib2data/test-src/automaton/AutomatonTemplatesTest.cpp b/alib2data/test-src/automaton/AutomatonTemplatesTest.cpp
index 22e884acf6..7b56813d9d 100644
--- a/alib2data/test-src/automaton/AutomatonTemplatesTest.cpp
+++ b/alib2data/test-src/automaton/AutomatonTemplatesTest.cpp
@@ -44,7 +44,7 @@ void AutomatonTemplatesTest::testDFAParser ( ) {
 
 		std::deque < sax::Token > tokens2;
 		sax::SaxParseInterface::parseMemory ( tmp, tokens2 );
-		automaton::DFA < char, int > automaton2 = alib::XmlDataFactory::fromTokens < automaton::DFA < char, int > > ( std::move ( tokens2 ) );
+		automaton::DFA < char, int > automaton2 = alib::XmlDataFactory::fromTokens ( std::move ( tokens2 ) );
 
 		CPPUNIT_ASSERT ( automaton == automaton2 );
 	}
@@ -55,7 +55,7 @@ void AutomatonTemplatesTest::testDFAParser ( ) {
 
 		std::deque < sax::Token > tokens2;
 		sax::SaxParseInterface::parseMemory ( tmp, tokens2 );
-		automaton::DFA < alib::Object, alib::Object > automaton2 = alib::XmlDataFactory::fromTokens < automaton::DFA < alib::Object, alib::Object > > ( std::move ( tokens2 ) );
+		automaton::DFA < alib::Object, alib::Object > automaton2 = alib::XmlDataFactory::fromTokens ( std::move ( tokens2 ) );
 
 		automaton::DFA < alib::Object, alib::Object > automaton3 ( alib::Object ( primitive::Integer ( 1 ) ) );
 
diff --git a/alib2data/test-src/automaton/AutomatonTest.cpp b/alib2data/test-src/automaton/AutomatonTest.cpp
index 49e6f17d10..6bc31393ab 100644
--- a/alib2data/test-src/automaton/AutomatonTest.cpp
+++ b/alib2data/test-src/automaton/AutomatonTest.cpp
@@ -53,7 +53,7 @@ void AutomatonTest::testDFAParser() {
 
 		std::deque<sax::Token> tokens2;
 		sax::SaxParseInterface::parseMemory(tmp, tokens2);
-		automaton::DFA<> automaton2 = alib::XmlDataFactory::fromTokens<automaton::DFA<>>(std::move(tokens2));
+		automaton::DFA<> automaton2 = alib::XmlDataFactory::fromTokens (std::move(tokens2));
 
 		CPPUNIT_ASSERT( automaton == automaton2 );
 	}
@@ -270,7 +270,7 @@ void AutomatonTest::testNFTAParser() {
 
 		std::deque<sax::Token> tokens2;
 		sax::SaxParseInterface::parseMemory(tmp, tokens2);
-		automaton::NFTA < > automaton2 = alib::XmlDataFactory::fromTokens<automaton::NFTA < > >(std::move(tokens2));
+		automaton::NFTA < > automaton2 = alib::XmlDataFactory::fromTokens (std::move(tokens2));
 
 		CPPUNIT_ASSERT( automaton == automaton2 );
 	}
diff --git a/alib2data/test-src/common/SparseBoolVectorTest.cpp b/alib2data/test-src/common/SparseBoolVectorTest.cpp
index 1b2412ba71..d7711a2e48 100644
--- a/alib2data/test-src/common/SparseBoolVectorTest.cpp
+++ b/alib2data/test-src/common/SparseBoolVectorTest.cpp
@@ -404,7 +404,7 @@ void SparseBoolVectorTest::testXmlApi() {
 
 	std::deque<sax::Token> tokens2;
 	sax::SaxParseInterface::parseMemory(tmp, tokens2);
-	common::SparseBoolVector data2 = alib::XmlDataFactory::fromTokens < common::SparseBoolVector > ( std::move ( tokens2 ) );
+	common::SparseBoolVector data2 = alib::XmlDataFactory::fromTokens ( std::move ( tokens2 ) );
 
 	std::cout << data.data ( ) << std::endl;
 	std::cout << data2.data ( ) << std::endl;
diff --git a/alib2data/test-src/grammar/GrammarTest.cpp b/alib2data/test-src/grammar/GrammarTest.cpp
index ad415b66c2..2a8f92314f 100644
--- a/alib2data/test-src/grammar/GrammarTest.cpp
+++ b/alib2data/test-src/grammar/GrammarTest.cpp
@@ -58,7 +58,7 @@ void GrammarTest::testUnrestrictedParser() {
 
 		std::deque<sax::Token> tokens2;
 		sax::SaxParseInterface::parseMemory(tmp, tokens2);
-		grammar::UnrestrictedGrammar < > grammar2 = alib::XmlDataFactory::fromTokens<grammar::UnrestrictedGrammar < > >(std::move(tokens2));
+		grammar::UnrestrictedGrammar < > grammar2 = alib::XmlDataFactory::fromTokens (std::move(tokens2));
 
 		CPPUNIT_ASSERT( grammar == grammar2 );
 	}
@@ -85,7 +85,7 @@ void GrammarTest::testUnrestrictedParser() {
 
 		std::deque<sax::Token> tokens2;
 		sax::SaxParseInterface::parseMemory(tmp, tokens2);
-		grammar::ContextPreservingUnrestrictedGrammar < > grammar2 = alib::XmlDataFactory::fromTokens<grammar::ContextPreservingUnrestrictedGrammar < > >(std::move(tokens2));
+		grammar::ContextPreservingUnrestrictedGrammar < > grammar2 = alib::XmlDataFactory::fromTokens (std::move(tokens2));
 
 		CPPUNIT_ASSERT( grammar == grammar2 );
 	}
@@ -112,7 +112,7 @@ void GrammarTest::testRegularParser() {
 
 			std::deque<sax::Token> tokens2;
 			sax::SaxParseInterface::parseMemory(tmp, tokens2);
-			grammar::RightRG < > grammar2 = alib::XmlDataFactory::fromTokens<grammar::RightRG < > >(std::move(tokens2));
+			grammar::RightRG < > grammar2 = alib::XmlDataFactory::fromTokens (std::move(tokens2));
 
 			CPPUNIT_ASSERT( grammar == grammar2 );
 		}
@@ -142,7 +142,7 @@ void GrammarTest::testRegularParser() {
 
 			std::deque<sax::Token> tokens2;
 			sax::SaxParseInterface::parseMemory(tmp, tokens2);
-			grammar::RightLG < > grammar2 = alib::XmlDataFactory::fromTokens<grammar::RightLG < > >(std::move(tokens2));
+			grammar::RightLG < > grammar2 = alib::XmlDataFactory::fromTokens (std::move(tokens2));
 
 			CPPUNIT_ASSERT( grammar == grammar2 );
 		}
@@ -172,7 +172,7 @@ void GrammarTest::testContextFreeParser() {
 
 			std::deque<sax::Token> tokens2;
 			sax::SaxParseInterface::parseMemory(tmp, tokens2);
-			grammar::LG < > grammar2 = alib::XmlDataFactory::fromTokens<grammar::LG < > >(std::move(tokens2));
+			grammar::LG < > grammar2 = alib::XmlDataFactory::fromTokens (std::move(tokens2));
 
 			CPPUNIT_ASSERT( grammar == grammar2 );
 		}
@@ -200,7 +200,7 @@ void GrammarTest::testContextFreeParser() {
 
 			std::deque<sax::Token> tokens2;
 			sax::SaxParseInterface::parseMemory(tmp, tokens2);
-			grammar::EpsilonFreeCFG < > grammar2 = alib::XmlDataFactory::fromTokens<grammar::EpsilonFreeCFG < > >(std::move(tokens2));
+			grammar::EpsilonFreeCFG < > grammar2 = alib::XmlDataFactory::fromTokens (std::move(tokens2));
 
 			CPPUNIT_ASSERT( grammar == grammar2 );
 		}
@@ -228,7 +228,7 @@ void GrammarTest::testContextFreeParser() {
 
 			std::deque<sax::Token> tokens2;
 			sax::SaxParseInterface::parseMemory(tmp, tokens2);
-			grammar::CFG < > grammar2 = alib::XmlDataFactory::fromTokens < grammar::CFG < > >(std::move(tokens2));
+			grammar::CFG < > grammar2 = alib::XmlDataFactory::fromTokens (std::move(tokens2));
 
 			CPPUNIT_ASSERT( grammar == grammar2 );
 		}
@@ -256,7 +256,7 @@ void GrammarTest::testContextFreeParser() {
 
 			std::deque<sax::Token> tokens2;
 			sax::SaxParseInterface::parseMemory(tmp, tokens2);
-			grammar::CNF < > grammar2 = alib::XmlDataFactory::fromTokens<grammar::CNF < > >(std::move(tokens2));
+			grammar::CNF < > grammar2 = alib::XmlDataFactory::fromTokens (std::move(tokens2));
 
 			CPPUNIT_ASSERT( grammar == grammar2 );
 		}
@@ -284,7 +284,7 @@ void GrammarTest::testContextFreeParser() {
 
 			std::deque<sax::Token> tokens2;
 			sax::SaxParseInterface::parseMemory(tmp, tokens2);
-			grammar::GNF < > grammar2 = alib::XmlDataFactory::fromTokens<grammar::GNF < > >(std::move(tokens2));
+			grammar::GNF < > grammar2 = alib::XmlDataFactory::fromTokens (std::move(tokens2));
 
 			CPPUNIT_ASSERT( grammar == grammar2 );
 		}
@@ -314,7 +314,7 @@ void GrammarTest::testContextSensitiveParser() {
 
 			std::deque<sax::Token> tokens2;
 			sax::SaxParseInterface::parseMemory(tmp, tokens2);
-			grammar::CSG < > grammar2 = alib::XmlDataFactory::fromTokens<grammar::CSG < > >(std::move(tokens2));
+			grammar::CSG < > grammar2 = alib::XmlDataFactory::fromTokens (std::move(tokens2));
 
 			CPPUNIT_ASSERT( grammar == grammar2 );
 		}
@@ -341,7 +341,7 @@ void GrammarTest::testContextSensitiveParser() {
 
 			std::deque<sax::Token> tokens2;
 			sax::SaxParseInterface::parseMemory(tmp, tokens2);
-			grammar::NonContractingGrammar < > grammar2 = alib::XmlDataFactory::fromTokens<grammar::NonContractingGrammar < > >(std::move(tokens2));
+			grammar::NonContractingGrammar < > grammar2 = alib::XmlDataFactory::fromTokens (std::move(tokens2));
 
 			CPPUNIT_ASSERT( grammar == grammar2 );
 		}
diff --git a/alib2data/test-src/label/LabelTest.cpp b/alib2data/test-src/label/LabelTest.cpp
index 4c2dee78d0..dea4ab32cf 100644
--- a/alib2data/test-src/label/LabelTest.cpp
+++ b/alib2data/test-src/label/LabelTest.cpp
@@ -47,13 +47,13 @@ void LabelTest::testXMLParser() {
 
 		std::deque<sax::Token> tokens2;
 		sax::SaxParseInterface::parseMemory(tmp, tokens2);
-		label::Label label2 = alib::XmlDataFactory::fromTokens<label::Label>(std::move(tokens2));
+		label::Label label2 = alib::XmlDataFactory::fromTokens (std::move(tokens2));
 
 		CPPUNIT_ASSERT( label == label2 );
 	}
 	{
 		std::string tmp = alib::XmlDataFactory::toString(label);
-		label::Label label2 = alib::XmlDataFactory::fromString<label::Label>(tmp);
+		label::Label label2 = alib::XmlDataFactory::fromString (tmp);
 
 		CPPUNIT_ASSERT( label == label2 );
 	}
diff --git a/alib2data/test-src/regexp/RegExpTest.cpp b/alib2data/test-src/regexp/RegExpTest.cpp
index 353f696580..ae97c43b3b 100644
--- a/alib2data/test-src/regexp/RegExpTest.cpp
+++ b/alib2data/test-src/regexp/RegExpTest.cpp
@@ -112,13 +112,13 @@ void RegExpTest::testXMLParser() {
 
 		std::deque<sax::Token> tokens2;
 		sax::SaxParseInterface::parseMemory(tmp, tokens2);
-		regexp::RegExp regexp2 = alib::XmlDataFactory::fromTokens<regexp::RegExp>(std::move(tokens2));
+		regexp::RegExp regexp2 = alib::XmlDataFactory::fromTokens (std::move(tokens2));
 
 		CPPUNIT_ASSERT( regexp == regexp2 );
 	}
 	{
 		std::string tmp = alib::XmlDataFactory::toString(regexp);
-		regexp::RegExp regexp2 = alib::XmlDataFactory::fromString<regexp::RegExp>(tmp);
+		regexp::RegExp regexp2 = alib::XmlDataFactory::fromString (tmp);
 
 		CPPUNIT_ASSERT( regexp == regexp2 );
 	}
diff --git a/alib2data/test-src/rte/RTETest.cpp b/alib2data/test-src/rte/RTETest.cpp
index 1c6aeb22ef..1e112f511e 100644
--- a/alib2data/test-src/rte/RTETest.cpp
+++ b/alib2data/test-src/rte/RTETest.cpp
@@ -125,13 +125,13 @@ void RTETest::testXMLParser ( ) {
 
 		std::deque < sax::Token > tokens2;
 		sax::SaxParseInterface::parseMemory ( tmp, tokens2 );
-		rte::RTE rte2 = alib::XmlDataFactory::fromTokens < rte::RTE > ( std::move ( tokens2 ) );
+		rte::RTE rte2 = alib::XmlDataFactory::fromTokens ( std::move ( tokens2 ) );
 
 		CPPUNIT_ASSERT ( rte == rte2 );
 	}
 	{
 		std::string tmp = alib::XmlDataFactory::toString ( rte );
-		rte::RTE rte2 = alib::XmlDataFactory::fromString < rte::RTE > ( tmp );
+		rte::RTE rte2 = alib::XmlDataFactory::fromString ( tmp );
 
 		CPPUNIT_ASSERT ( rte == rte2 );
 	}
diff --git a/alib2data/test-src/string/StringTest.cpp b/alib2data/test-src/string/StringTest.cpp
index eb9fa29f6d..ec2c02aff2 100644
--- a/alib2data/test-src/string/StringTest.cpp
+++ b/alib2data/test-src/string/StringTest.cpp
@@ -57,14 +57,14 @@ void StringTest::testXMLParser ( ) {
 
 		std::deque < sax::Token > tokens2;
 		sax::SaxParseInterface::parseMemory ( tmp, tokens2 );
-		string::String string2 = alib::XmlDataFactory::fromTokens < string::String > ( std::move( tokens2 ) );
+		string::String string2 = alib::XmlDataFactory::fromTokens ( std::move( tokens2 ) );
 
 		CPPUNIT_ASSERT ( string == string2 );
 	}
 	{
 		std::string tmp = alib::XmlDataFactory::toString ( string );
 		std::cout << tmp << std::endl;
-		string::String string2 = alib::XmlDataFactory::fromString < string::String > ( tmp );
+		string::String string2 = alib::XmlDataFactory::fromString ( tmp );
 
 		CPPUNIT_ASSERT ( string == string2 );
 	}
diff --git a/alib2data/test-src/tree/PatternTest.cpp b/alib2data/test-src/tree/PatternTest.cpp
index bea2a26e55..2d73f325bc 100644
--- a/alib2data/test-src/tree/PatternTest.cpp
+++ b/alib2data/test-src/tree/PatternTest.cpp
@@ -50,7 +50,7 @@ void PatternTest::testRankedPatternParser() {
 
 		std::deque<sax::Token> tokens2;
 		sax::SaxParseInterface::parseMemory(tmp, tokens2);
-		tree::RankedPattern < > tree2 = alib::XmlDataFactory::fromTokens<tree::RankedPattern < > >(std::move(tokens2));
+		tree::RankedPattern < > tree2 = alib::XmlDataFactory::fromTokens (std::move(tokens2));
 
 		CPPUNIT_ASSERT( tree == tree2 );
 		std::cout << std::endl;
@@ -100,7 +100,7 @@ void PatternTest::testUnrankedPatternParser() {
 
 		std::deque<sax::Token> tokens2;
 		sax::SaxParseInterface::parseMemory(tmp, tokens2);
-		tree::UnrankedPattern < > tree2 = alib::XmlDataFactory::fromTokens<tree::UnrankedPattern < > >(std::move(tokens2));
+		tree::UnrankedPattern < > tree2 = alib::XmlDataFactory::fromTokens (std::move(tokens2));
 
 		CPPUNIT_ASSERT( tree == tree2 );
 		std::cout << std::endl;
@@ -150,7 +150,7 @@ void PatternTest::testPrefixRankedPatternParser() {
 
 		std::deque<sax::Token> tokens2;
 		sax::SaxParseInterface::parseMemory(tmp, tokens2);
-		tree::PrefixRankedPattern < > pattern3 = alib::XmlDataFactory::fromTokens<tree::PrefixRankedPattern < > >(std::move(tokens2));
+		tree::PrefixRankedPattern < > pattern3 = alib::XmlDataFactory::fromTokens (std::move(tokens2));
 
 		CPPUNIT_ASSERT( pattern2 == pattern3 );
 		std::cout << std::endl;
@@ -183,7 +183,7 @@ void PatternTest::testPrefixRankedBarPatternParser() {
 
 		std::deque<sax::Token> tokens2;
 		sax::SaxParseInterface::parseMemory(tmp, tokens2);
-		tree::PrefixRankedBarPattern < > pattern3 = alib::XmlDataFactory::fromTokens<tree::PrefixRankedBarPattern < > >(std::move(tokens2));
+		tree::PrefixRankedBarPattern < > pattern3 = alib::XmlDataFactory::fromTokens (std::move(tokens2));
 
 		CPPUNIT_ASSERT( pattern2 == pattern3 );
 		std::cout << std::endl;
diff --git a/alib2data/test-src/tree/TreeTest.cpp b/alib2data/test-src/tree/TreeTest.cpp
index 75d177a643..52bc43601d 100644
--- a/alib2data/test-src/tree/TreeTest.cpp
+++ b/alib2data/test-src/tree/TreeTest.cpp
@@ -71,7 +71,7 @@ void TreeTest::testRankedTreeParser() {
 
 		std::deque<sax::Token> tokens2;
 		sax::SaxParseInterface::parseMemory(tmp, tokens2);
-		tree::RankedTree < > tree2 = alib::XmlDataFactory::fromTokens<tree::RankedTree < > >(std::move(tokens2));
+		tree::RankedTree < > tree2 = alib::XmlDataFactory::fromTokens (std::move(tokens2));
 
 		CPPUNIT_ASSERT( tree == tree2 );
 		std::cout << std::endl;
@@ -196,7 +196,7 @@ void TreeTest::testUnrankedTreeParser() {
 
 		std::deque<sax::Token> tokens2;
 		sax::SaxParseInterface::parseMemory(tmp, tokens2);
-		tree::UnrankedTree < > tree2 = alib::XmlDataFactory::fromTokens<tree::UnrankedTree < > >(std::move(tokens2));
+		tree::UnrankedTree < > tree2 = alib::XmlDataFactory::fromTokens (std::move(tokens2));
 
 		CPPUNIT_ASSERT( tree == tree2 );
 		std::cout << std::endl;
@@ -303,7 +303,7 @@ void TreeTest::testPrefixRankedBarParser() {
 
 		std::deque<sax::Token> tokens2;
 		sax::SaxParseInterface::parseMemory(tmp, tokens2);
-		tree::PrefixRankedBarTree < > tree3 = alib::XmlDataFactory::fromTokens<tree::PrefixRankedBarTree < > >(std::move(tokens2));
+		tree::PrefixRankedBarTree < > tree3 = alib::XmlDataFactory::fromTokens (std::move(tokens2));
 
 		CPPUNIT_ASSERT( tree2 == tree3 );
 		std::cout << std::endl;
diff --git a/alib2data_experimental/test-src/graph/GraphTest.cpp b/alib2data_experimental/test-src/graph/GraphTest.cpp
index b6783a86a6..f7c7363eaa 100644
--- a/alib2data_experimental/test-src/graph/GraphTest.cpp
+++ b/alib2data_experimental/test-src/graph/GraphTest.cpp
@@ -129,7 +129,7 @@ void testXMLParser_impl()
 
 	graph::Graph dg1(dg);
 	std::string tmp = alib::XmlDataFactory::toString(dg1);
-	graph::Graph dg2 = alib::XmlDataFactory::fromString<graph::Graph>(tmp);
+	graph::Graph dg2 = alib::XmlDataFactory::fromString (tmp);
 	CPPUNIT_ASSERT(dg1 == dg2);
 
 	dg.setEdgeValue(graph::DirectedEdge(n1, n2), 1);
@@ -137,7 +137,7 @@ void testXMLParser_impl()
 
 	graph::Graph dg1_2(dg);
 	tmp = alib::XmlDataFactory::toString(dg1_2);
-	graph::Graph dg2_2 = alib::XmlDataFactory::fromString<graph::Graph>(tmp);
+	graph::Graph dg2_2 = alib::XmlDataFactory::fromString (tmp);
 	CPPUNIT_ASSERT(dg1_2 == dg2_2);
 
 	// Undirected
@@ -150,7 +150,7 @@ void testXMLParser_impl()
 
 	graph::Graph ug1(ug);
 	tmp = alib::XmlDataFactory::toString(ug1);
-	graph::Graph ug2 = alib::XmlDataFactory::fromString<graph::Graph>(tmp);
+	graph::Graph ug2 = alib::XmlDataFactory::fromString (tmp);
 	CPPUNIT_ASSERT(ug1 == ug2);
 
 	ug.setEdgeValue(graph::UndirectedEdge(n1, n2), 1);
@@ -158,7 +158,7 @@ void testXMLParser_impl()
 
 	graph::Graph ug1_2(ug);
 	tmp = alib::XmlDataFactory::toString(ug1_2);
-	graph::Graph ug2_2 = alib::XmlDataFactory::fromString<graph::Graph>(tmp);
+	graph::Graph ug2_2 = alib::XmlDataFactory::fromString (tmp);
 	CPPUNIT_ASSERT(ug1_2 == ug2_2);
 }
 
diff --git a/alib2str/src/factory/StringDataFactory.hpp b/alib2str/src/factory/StringDataFactory.hpp
index 4e126d23d2..7e3ada422f 100644
--- a/alib2str/src/factory/StringDataFactory.hpp
+++ b/alib2str/src/factory/StringDataFactory.hpp
@@ -18,34 +18,67 @@ namespace alib {
 
 class StringDataFactory {
 public:
+	class fromFile {
+		const std::string & filename;
 
-	template<class T>
-	static T fromFile(const std::string& filename) {
-		std::ifstream fileStream(filename);
-		return fromStream<T>(fileStream);
-	}
+	public:
+		fromFile ( const std::string & file ) : filename ( file ) {
+		}
 
-	template<class T>
-	static T fromString(const std::string& str) {
-		std::stringstream stringStream(str);
-		return fromStream<T>(stringStream);
-	}
+		template < class T >
+		operator T ( ) {
+			std::ifstream fileStream ( filename );
 
-	template<class T>
-	static T fromStdin() {
-		return fromStream<T>(std::cin);
-	}
+			return fromStream ( fileStream );
+		}
+	};
 
-	template<class T>
-	static T fromStream(std::istream& in) {
-		if(in.peek() == EOF) throw exception::CommonException("Empty stream");
+	class fromString {
+		const std::string & string;
 
-		T res = alib::stringApi<T>::parse(in);
+	public:
+		fromString ( const std::string & str ) : string ( str ) {
+		}
 
-		while(isspace(in.peek())) in.get();
-		if(in.peek() != EOF) throw exception::CommonException("Unexpected characters at the end of the stream");
-		return res;
-	}
+		template < class T >
+		operator T ( ) {
+			std::stringstream stringStream ( string );
+
+			return fromStream ( stringStream );
+		}
+	};
+
+	class fromStdin {
+	public:
+		template < class T >
+		operator T ( ) {
+			return fromStream ( std::cin );
+		}
+	};
+
+	class fromStream {
+		std::istream & in;
+
+	public:
+		fromStream ( std::istream & i ) : in ( i ) {
+		}
+
+		template < class T >
+		operator T ( ) {
+			if ( in.peek ( ) == EOF )
+				throw exception::CommonException ( "Empty stream" );
+
+			T res = alib::stringApi < T >::parse ( in );
+
+			while ( isspace ( in.peek ( ) ) )
+				in.get ( );
+
+			if ( in.peek ( ) != EOF )
+				throw exception::CommonException ( "Unexpected characters at the end of the stream" );
+
+			return res;
+		}
+	};
 
 	template<class T>
 	static void toFile(const T& data, const std::string& filename) {
diff --git a/alib2str/test-src/automaton/AutomatonTest.cpp b/alib2str/test-src/automaton/AutomatonTest.cpp
index 6e7585d0e1..26a0deca87 100644
--- a/alib2str/test-src/automaton/AutomatonTest.cpp
+++ b/alib2str/test-src/automaton/AutomatonTest.cpp
@@ -42,13 +42,13 @@ void AutomatonTest::FSMStringParserTest() {
 					"3 - - 4 - -\n"
 					"4 - 5 - - 5\n"
 					"<5 - - - - 3\n";
-		automaton::Automaton automaton = alib::StringDataFactory::fromString<automaton::Automaton>(input);
+		automaton::Automaton automaton = alib::StringDataFactory::fromString (input);
 
 		std::string output = alib::StringDataFactory::toString(automaton);
 
 		CPPUNIT_ASSERT( input == output );
 
-		automaton::Automaton automaton2 = alib::StringDataFactory::fromString<automaton::Automaton>(output);
+		automaton::Automaton automaton2 = alib::StringDataFactory::fromString (output);
 
 		CPPUNIT_ASSERT( automaton == automaton2 );
 	}
@@ -60,13 +60,13 @@ void AutomatonTest::FSMStringParserTest() {
 					">3 - - 4 -\n"
 					"4 - 5 - -\n"
 					"<5 - - - 3\n";
-		automaton::Automaton automaton = alib::StringDataFactory::fromString<automaton::Automaton>(input);
+		automaton::Automaton automaton = alib::StringDataFactory::fromString (input);
 
 		std::string output = alib::StringDataFactory::toString(automaton);
 
 		CPPUNIT_ASSERT( input == output );
 
-		automaton::Automaton automaton2 = alib::StringDataFactory::fromString<automaton::Automaton>(output);
+		automaton::Automaton automaton2 = alib::StringDataFactory::fromString (output);
 
 		CPPUNIT_ASSERT( automaton == automaton2 );
 	}
@@ -78,13 +78,13 @@ void AutomatonTest::FSMStringParserTest() {
 					"3 - - 4 -\n"
 					"4 - 5 - -\n"
 					"<5 - - - 3\n";
-		automaton::Automaton automaton = alib::StringDataFactory::fromString<automaton::Automaton>(input);
+		automaton::Automaton automaton = alib::StringDataFactory::fromString (input);
 
 		std::string output = alib::StringDataFactory::toString(automaton);
 
 		CPPUNIT_ASSERT( input == output );
 
-		automaton::Automaton automaton2 = alib::StringDataFactory::fromString<automaton::Automaton>(output);
+		automaton::Automaton automaton2 = alib::StringDataFactory::fromString (output);
 
 		CPPUNIT_ASSERT( automaton == automaton2 );
 	}
@@ -96,13 +96,13 @@ void AutomatonTest::FSMStringParserTest() {
 					"3 - - 4 -\n"
 					"4 - 5 - -\n"
 					"<5 - - - 3\n";
-		automaton::Automaton automaton = alib::StringDataFactory::fromString<automaton::Automaton>(input);
+		automaton::Automaton automaton = alib::StringDataFactory::fromString (input);
 
 		std::string output = alib::StringDataFactory::toString(automaton);
 
 		CPPUNIT_ASSERT( input == output );
 
-		automaton::Automaton automaton2 = alib::StringDataFactory::fromString<automaton::Automaton>(output);
+		automaton::Automaton automaton2 = alib::StringDataFactory::fromString (output);
 
 		CPPUNIT_ASSERT( automaton == automaton2 );
 	}
diff --git a/alib2str/test-src/grammar/GrammarTest.cpp b/alib2str/test-src/grammar/GrammarTest.cpp
index 27c90c89f3..a40fa023d1 100644
--- a/alib2str/test-src/grammar/GrammarTest.cpp
+++ b/alib2str/test-src/grammar/GrammarTest.cpp
@@ -44,14 +44,14 @@ void GrammarTest::stringParserTest() {
 					"  B -> B B | b,\n"
 					"  S -> | B S | S A},\n"
 					"S)\n";
-		grammar::Grammar grammar = alib::StringDataFactory::fromString<grammar::Grammar>(input);
+		grammar::Grammar grammar = alib::StringDataFactory::fromString (input);
 
 		std::string output = alib::StringDataFactory::toString(grammar);
 
 		std::cout << "\"" << input << "\"" << std::endl << std::endl << "\"" << output << "\"" << std::endl;
 		CPPUNIT_ASSERT( input == output );
 
-		grammar::Grammar grammar2 = alib::StringDataFactory::fromString<grammar::Grammar>(output);
+		grammar::Grammar grammar2 = alib::StringDataFactory::fromString (output);
 
 		CPPUNIT_ASSERT( grammar == grammar2 );
 	}
@@ -63,14 +63,14 @@ void GrammarTest::stringParserTest() {
 					"  B -> b | b B,\n"
 					"  S -> | a A | a S | b B},\n"
 					"S)\n";
-		grammar::Grammar grammar = alib::StringDataFactory::fromString<grammar::Grammar>(input);
+		grammar::Grammar grammar = alib::StringDataFactory::fromString (input);
 
 		std::string output = alib::StringDataFactory::toString(grammar);
 
 		std::cout << "\"" << input << "\"" << std::endl << std::endl << "\"" << output << "\"" << std::endl;
 		CPPUNIT_ASSERT( input == output );
 
-		grammar::Grammar grammar2 = alib::StringDataFactory::fromString<grammar::Grammar>(output);
+		grammar::Grammar grammar2 = alib::StringDataFactory::fromString (output);
 
 		CPPUNIT_ASSERT( grammar == grammar2 );
 	}
@@ -82,14 +82,14 @@ void GrammarTest::stringParserTest() {
 					"  B -> b | b B,\n"
 					"  S -> A S | B B | S A},\n"
 					"S)\n";
-		grammar::Grammar grammar = alib::StringDataFactory::fromString<grammar::Grammar>(input);
+		grammar::Grammar grammar = alib::StringDataFactory::fromString (input);
 
 		std::string output = alib::StringDataFactory::toString(grammar);
 
 		std::cout << "\"" << input << "\"" << std::endl << std::endl << "\"" << output << "\"" << std::endl;
 		CPPUNIT_ASSERT( input == output );
 
-		grammar::Grammar grammar2 = alib::StringDataFactory::fromString<grammar::Grammar>(output);
+		grammar::Grammar grammar2 = alib::StringDataFactory::fromString (output);
 
 		CPPUNIT_ASSERT( grammar == grammar2 );
 	}
@@ -101,14 +101,14 @@ void GrammarTest::stringParserTest() {
 					"  | S | -> A S | B B | S A,\n"
 					"  A | A | -> B B | a A},\n"
 					"S)\n";
-		grammar::Grammar grammar = alib::StringDataFactory::fromString<grammar::Grammar>(input);
+		grammar::Grammar grammar = alib::StringDataFactory::fromString (input);
 
 		std::string output = alib::StringDataFactory::toString(grammar);
 
 		std::cout << "\"" << input << "\"" << std::endl << std::endl << "\"" << output << "\"" << std::endl;
 		CPPUNIT_ASSERT( input == output );
 
-		grammar::Grammar grammar2 = alib::StringDataFactory::fromString<grammar::Grammar>(output);
+		grammar::Grammar grammar2 = alib::StringDataFactory::fromString (output);
 
 		CPPUNIT_ASSERT( grammar == grammar2 );
 	}
diff --git a/alib2str/test-src/object/LabelTest.cpp b/alib2str/test-src/object/LabelTest.cpp
index fb218fa961..01d73e273e 100644
--- a/alib2str/test-src/object/LabelTest.cpp
+++ b/alib2str/test-src/object/LabelTest.cpp
@@ -16,49 +16,49 @@ void LabelTest::tearDown() {
 void LabelTest::testEqual() {
 	{
 		std::string input = "1";
-		alib::Object label = alib::StringDataFactory::fromString<alib::Object>(input);
+		alib::Object label = alib::StringDataFactory::fromString (input);
 
 		std::string output = alib::StringDataFactory::toString(label);
 
 		CPPUNIT_ASSERT( input == output );
 
-		alib::Object label2 = alib::StringDataFactory::fromString<alib::Object>(output);
+		alib::Object label2 = alib::StringDataFactory::fromString (output);
 
 		CPPUNIT_ASSERT( label == label2 );
 	}
 	{
 		std::string input = "aaaa";
-		alib::Object label = alib::StringDataFactory::fromString<alib::Object>(input);
+		alib::Object label = alib::StringDataFactory::fromString (input);
 
 		std::string output = alib::StringDataFactory::toString(label);
 
 		CPPUNIT_ASSERT( input == output );
 
-		alib::Object label2 = alib::StringDataFactory::fromString<alib::Object>(output);
+		alib::Object label2 = alib::StringDataFactory::fromString (output);
 
 		CPPUNIT_ASSERT( label == label2 );
 	}
 	{
 		std::string input = "[1, 2, 3]";
-		alib::Object label = alib::StringDataFactory::fromString<alib::Object>(input);
+		alib::Object label = alib::StringDataFactory::fromString (input);
 
 		std::string output = alib::StringDataFactory::toString(label);
 
 		CPPUNIT_ASSERT( input == output );
 
-		alib::Object label2 = alib::StringDataFactory::fromString<alib::Object>(output);
+		alib::Object label2 = alib::StringDataFactory::fromString (output);
 
 		CPPUNIT_ASSERT( label == label2 );
 	}
 	{
 		std::string input = "<1, 2>";
-		alib::Object label = alib::StringDataFactory::fromString<alib::Object>(input);
+		alib::Object label = alib::StringDataFactory::fromString (input);
 
 		std::string output = alib::StringDataFactory::toString(label);
 
 		CPPUNIT_ASSERT( input == output );
 
-		alib::Object label2 = alib::StringDataFactory::fromString<alib::Object>(output);
+		alib::Object label2 = alib::StringDataFactory::fromString (output);
 
 		CPPUNIT_ASSERT( label == label2 );
 	}
diff --git a/alib2str/test-src/object/ObjectTest.cpp b/alib2str/test-src/object/ObjectTest.cpp
index a2147d5441..c763d5f563 100644
--- a/alib2str/test-src/object/ObjectTest.cpp
+++ b/alib2str/test-src/object/ObjectTest.cpp
@@ -17,7 +17,7 @@ void ObjectTest::tearDown() {
 
 void ObjectTest::testComposing() {
 	std::string input = "<1, 2>";
-	alib::Object label = alib::StringDataFactory::fromString<alib::Object>(input);
+	alib::Object label = alib::StringDataFactory::fromString (input);
 
 	std::string output = alib::StringDataFactory::toString(label);
 	CPPUNIT_ASSERT( input == output );
diff --git a/alib2str/test-src/object/SymbolTest.cpp b/alib2str/test-src/object/SymbolTest.cpp
index 5b743901b0..0aa3150541 100644
--- a/alib2str/test-src/object/SymbolTest.cpp
+++ b/alib2str/test-src/object/SymbolTest.cpp
@@ -16,25 +16,25 @@ void SymbolTest::tearDown() {
 void SymbolTest::testEqual() {
 	{
 		std::string input = "a";
-		alib::Object symbol = alib::StringDataFactory::fromString<alib::Object>(input);
+		alib::Object symbol = alib::StringDataFactory::fromString (input);
 
 		std::string output = alib::StringDataFactory::toString(symbol);
 
 		CPPUNIT_ASSERT( input == output );
 
-		alib::Object symbol2 = alib::StringDataFactory::fromString<alib::Object>(output);
+		alib::Object symbol2 = alib::StringDataFactory::fromString (output);
 
 		CPPUNIT_ASSERT( symbol == symbol2 );
 	}
 	{
 		std::string input = "aaaa";
-		alib::Object symbol = alib::StringDataFactory::fromString<alib::Object>(input);
+		alib::Object symbol = alib::StringDataFactory::fromString (input);
 
 		std::string output = alib::StringDataFactory::toString(symbol);
 
 		CPPUNIT_ASSERT( input == output );
 
-		alib::Object symbol2 = alib::StringDataFactory::fromString<alib::Object>(output);
+		alib::Object symbol2 = alib::StringDataFactory::fromString (output);
 
 		CPPUNIT_ASSERT( symbol == symbol2 );
 	}
diff --git a/alib2str/test-src/regexp/RegExpTest.cpp b/alib2str/test-src/regexp/RegExpTest.cpp
index 97d308135f..97b2e931e0 100644
--- a/alib2str/test-src/regexp/RegExpTest.cpp
+++ b/alib2str/test-src/regexp/RegExpTest.cpp
@@ -25,38 +25,38 @@ void RegExpTest::tearDown() {
 void RegExpTest::testEqual() {
 	{
 		std::string input = "#E* #0*";
-		regexp::RegExp regexp = alib::StringDataFactory::fromString<regexp::RegExp>(input);
+		regexp::RegExp regexp = alib::StringDataFactory::fromString (input);
 
 		std::string output = alib::StringDataFactory::toString(regexp);
 
 		CPPUNIT_ASSERT( input == output );
 
-		regexp::RegExp regexp2 = alib::StringDataFactory::fromString<regexp::RegExp>(output);
+		regexp::RegExp regexp2 = alib::StringDataFactory::fromString (output);
 
 		CPPUNIT_ASSERT( regexp == regexp2 );
 	}
 	{
 		std::string input = "a+a";
-		regexp::RegExp regexp = alib::StringDataFactory::fromString<regexp::RegExp>(input);
+		regexp::RegExp regexp = alib::StringDataFactory::fromString (input);
 
 		std::string output = alib::StringDataFactory::toString(regexp);
 
 		CPPUNIT_ASSERT( input == output );
 
-		regexp::RegExp regexp2 = alib::StringDataFactory::fromString<regexp::RegExp>(output);
+		regexp::RegExp regexp2 = alib::StringDataFactory::fromString (output);
 
 		CPPUNIT_ASSERT( regexp == regexp2 );
 	}
 	{
 		std::string input = "a+a (b+a)*";
-		regexp::RegExp regexp = alib::StringDataFactory::fromString<regexp::RegExp>(input);
+		regexp::RegExp regexp = alib::StringDataFactory::fromString (input);
 
 		std::string output = alib::StringDataFactory::toString(regexp);
 
 		CPPUNIT_ASSERT( input == output );
 		std::cout << output << std::endl;
 
-		regexp::RegExp regexp2 = alib::StringDataFactory::fromString<regexp::RegExp>(output);
+		regexp::RegExp regexp2 = alib::StringDataFactory::fromString (output);
 
 		CPPUNIT_ASSERT( regexp == regexp2 );
 	}
diff --git a/alib2str/test-src/string/StringTest.cpp b/alib2str/test-src/string/StringTest.cpp
index e0ca33655d..8a77711b15 100644
--- a/alib2str/test-src/string/StringTest.cpp
+++ b/alib2str/test-src/string/StringTest.cpp
@@ -28,19 +28,19 @@ void StringTest::tearDown() {
 void StringTest::testEqual() {
 	{
 		std::string input = "\"aa\"";
-		string::String string = alib::StringDataFactory::fromString<string::String>(input);
+		string::String string = alib::StringDataFactory::fromString (input);
 
 		std::string output = alib::StringDataFactory::toString(string);
 
 		CPPUNIT_ASSERT( input == output );
 
-		string::String string2 = alib::StringDataFactory::fromString<string::String>(output);
+		string::String string2 = alib::StringDataFactory::fromString (output);
 
 		CPPUNIT_ASSERT( string == string2 );
 	}
 	{
 		std::string input = "\"aaaa aaa\"";
-		string::String string = alib::StringDataFactory::fromString<string::String>(input);
+		string::String string = alib::StringDataFactory::fromString (input);
 
 		std::string output = alib::StringDataFactory::toString(string);
 
@@ -48,19 +48,19 @@ void StringTest::testEqual() {
 
 		CPPUNIT_ASSERT( input == output );
 
-		string::String string2 = alib::StringDataFactory::fromString<string::String>(output);
+		string::String string2 = alib::StringDataFactory::fromString (output);
 
 		CPPUNIT_ASSERT( string == string2 );
 	}
 	{
 		std::string input = "#E";
-		string::String string = alib::StringDataFactory::fromString<string::String>(input);
+		string::String string = alib::StringDataFactory::fromString (input);
 
 		std::string output = alib::StringDataFactory::toString(string);
 
 		CPPUNIT_ASSERT( input == output );
 
-		string::String string2 = alib::StringDataFactory::fromString<string::String>(output);
+		string::String string2 = alib::StringDataFactory::fromString (output);
 
 		CPPUNIT_ASSERT( string == string2 );
 	}
diff --git a/alib2str/test-src/tree/TreeTest.cpp b/alib2str/test-src/tree/TreeTest.cpp
index c5a6b240ab..1a05acb921 100644
--- a/alib2str/test-src/tree/TreeTest.cpp
+++ b/alib2str/test-src/tree/TreeTest.cpp
@@ -24,75 +24,75 @@ void TreeTest::tearDown ( ) {
 void TreeTest::testEqual ( ) {
 	{
 		std::string input = "a0";
-		tree::Tree tree = alib::StringDataFactory::fromString < tree::Tree > ( input );
+		tree::Tree tree = alib::StringDataFactory::fromString ( input );
 
 		std::string output = alib::StringDataFactory::toString ( tree );
 
 		CPPUNIT_ASSERT ( input == output );
 
-		tree::Tree tree2 = alib::StringDataFactory::fromString < tree::Tree > ( output );
+		tree::Tree tree2 = alib::StringDataFactory::fromString ( output );
 
 		CPPUNIT_ASSERT ( tree == tree2 );
 	}
 	{
 		std::string input = "a |";
-		tree::Tree tree = alib::StringDataFactory::fromString < tree::Tree > ( input );
+		tree::Tree tree = alib::StringDataFactory::fromString ( input );
 
 		std::string output = alib::StringDataFactory::toString ( tree );
 
 		CPPUNIT_ASSERT ( input == output );
 
-		tree::Tree tree2 = alib::StringDataFactory::fromString < tree::Tree > ( output );
+		tree::Tree tree2 = alib::StringDataFactory::fromString ( output );
 
 		CPPUNIT_ASSERT ( tree == tree2 );
 	}
 	{
 		std::string input = "a2 a0 a1 a0";
-		tree::Tree tree = alib::StringDataFactory::fromString < tree::Tree > ( input );
+		tree::Tree tree = alib::StringDataFactory::fromString ( input );
 
 		std::string output = alib::StringDataFactory::toString ( tree );
 
 		CPPUNIT_ASSERT ( input == output );
 
-		tree::Tree tree2 = alib::StringDataFactory::fromString < tree::Tree > ( output );
+		tree::Tree tree2 = alib::StringDataFactory::fromString ( output );
 
 		CPPUNIT_ASSERT ( tree == tree2 );
 	}
 	{
 		std::string input = "a a | a a | | |";
-		tree::Tree tree = alib::StringDataFactory::fromString < tree::Tree > ( input );
+		tree::Tree tree = alib::StringDataFactory::fromString ( input );
 
 		std::string output = alib::StringDataFactory::toString ( tree );
 
 		CPPUNIT_ASSERT ( input == output );
 
-		tree::Tree tree2 = alib::StringDataFactory::fromString < tree::Tree > ( output );
+		tree::Tree tree2 = alib::StringDataFactory::fromString ( output );
 
 		CPPUNIT_ASSERT ( tree == tree2 );
 	}
 	{
 		std::string input = "a2 #S a1 a0";
-		tree::Tree tree = alib::StringDataFactory::fromString < tree::Tree > ( input );
+		tree::Tree tree = alib::StringDataFactory::fromString ( input );
 
 		std::string output = alib::StringDataFactory::toString ( tree );
 
 		std::cout << output << std::endl;
 		CPPUNIT_ASSERT ( input == output );
 
-		tree::Tree tree2 = alib::StringDataFactory::fromString < tree::Tree > ( output );
+		tree::Tree tree2 = alib::StringDataFactory::fromString ( output );
 
 		CPPUNIT_ASSERT ( tree == tree2 );
 	}
 	{
 		std::string input = "a #S | a a | | |";
-		tree::Tree tree = alib::StringDataFactory::fromString < tree::Tree > ( input );
+		tree::Tree tree = alib::StringDataFactory::fromString ( input );
 
 		std::string output = alib::StringDataFactory::toString ( tree );
 
 		std::cout << output << std::endl;
 		CPPUNIT_ASSERT ( input == output );
 
-		tree::Tree tree2 = alib::StringDataFactory::fromString < tree::Tree > ( output );
+		tree::Tree tree2 = alib::StringDataFactory::fromString ( output );
 
 		CPPUNIT_ASSERT ( tree == tree2 );
 	}
diff --git a/alib2str_experimental/test-src/graph/GraphTest.cpp b/alib2str_experimental/test-src/graph/GraphTest.cpp
index f04b7074c8..ce9ecd4b57 100644
--- a/alib2str_experimental/test-src/graph/GraphTest.cpp
+++ b/alib2str_experimental/test-src/graph/GraphTest.cpp
@@ -36,7 +36,7 @@ void testStringParser_impl()
 
 	graph::Graph dg1(dg);
 	std::string tmp = alib::StringDataFactory::toString(dg1);
-	graph::Graph dg2 = alib::StringDataFactory::fromString<graph::Graph>(tmp);
+	graph::Graph dg2 = alib::StringDataFactory::fromString (tmp);
 	std::string tmp2 = alib::StringDataFactory::toString(dg2);
 	CPPUNIT_ASSERT(dg1 == dg2);
 
@@ -45,7 +45,7 @@ void testStringParser_impl()
 
 	graph::Graph dg1_2(dg);
 	tmp = alib::StringDataFactory::toString(dg1_2);
-	graph::Graph dg2_2 = alib::StringDataFactory::fromString<graph::Graph>(tmp);
+	graph::Graph dg2_2 = alib::StringDataFactory::fromString (tmp);
 	CPPUNIT_ASSERT(dg1_2 == dg2_2);
 
 	// Undirected
@@ -58,7 +58,7 @@ void testStringParser_impl()
 
 	graph::Graph ug1(ug);
 	tmp = alib::StringDataFactory::toString(ug1);
-	graph::Graph ug2 = alib::StringDataFactory::fromString<graph::Graph>(tmp);
+	graph::Graph ug2 = alib::StringDataFactory::fromString (tmp);
 	CPPUNIT_ASSERT(ug1 == ug2);
 
 	ug.setEdgeValue(graph::UndirectedEdge(n1, n2), 1);
@@ -66,7 +66,7 @@ void testStringParser_impl()
 
 	graph::Graph ug1_2(ug);
 	tmp = alib::StringDataFactory::toString(ug1_2);
-	graph::Graph ug2_2 = alib::StringDataFactory::fromString<graph::Graph>(tmp);
+	graph::Graph ug2_2 = alib::StringDataFactory::fromString (tmp);
 	CPPUNIT_ASSERT(ug1_2 == ug2_2);
 }
 
diff --git a/aminimize2/src/aminimize.cpp b/aminimize2/src/aminimize.cpp
index 8a4739a3c9..62a94a7080 100644
--- a/aminimize2/src/aminimize.cpp
+++ b/aminimize2/src/aminimize.cpp
@@ -47,7 +47,7 @@ int main(int argc, char** argv) {
 		measurements::start("Overal", measurements::Type::OVERALL);
 		measurements::start("Input read", measurements::Type::AUXILIARY);
 
-		automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(sax::FromXMLParserHelper::parseInput(input));
+		automaton::Automaton automaton = alib::XmlDataFactory::fromTokens (sax::FromXMLParserHelper::parseInput(input));
 
 		measurements::end();
 		measurements::start("Algorithm", measurements::Type::MAIN);
diff --git a/anormalize2/src/anormalize.cpp b/anormalize2/src/anormalize.cpp
index ec55bffee9..fe55ec4247 100644
--- a/anormalize2/src/anormalize.cpp
+++ b/anormalize2/src/anormalize.cpp
@@ -75,7 +75,7 @@ int main ( int argc, char * * argv ) {
 		std::deque < sax::Token > tokens = sax::FromXMLParserHelper::parseInput(input);
 
 		if ( labels.getValue ( ) == "automaton" ) {
-			automaton::Automaton automaton = alib::XmlDataFactory::fromTokens < automaton::Automaton > ( std::move ( tokens ) );
+			automaton::Automaton automaton = alib::XmlDataFactory::fromTokens ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -87,7 +87,7 @@ int main ( int argc, char * * argv ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( labels.getValue ( ) == "grammar" ) {
-			// grammar::Grammar grammar = alib::XmlDataFactory::fromTokens<grammar::Grammar>( std::move ( tokens ) );
+			// grammar::Grammar grammar = alib::XmlDataFactory::fromTokens ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -99,7 +99,7 @@ int main ( int argc, char * * argv ) {
 
 			// alib::XmlDataFactory::toStdout(res);
 		} else if ( alphabet.getValue ( ) == "string" ) {
-			string::String string = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( tokens ) );
+			string::String string = alib::XmlDataFactory::fromTokens ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -111,7 +111,7 @@ int main ( int argc, char * * argv ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( form.getValue ( ) == "leftRG" ) {
-			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens < grammar::Grammar > ( std::move ( tokens ) );
+			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -123,7 +123,7 @@ int main ( int argc, char * * argv ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( form.getValue ( ) == "rightRG" ) {
-			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens < grammar::Grammar > ( std::move ( tokens ) );
+			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -135,7 +135,7 @@ int main ( int argc, char * * argv ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( form.getValue ( ) == "singleInitialState" ) {
-			automaton::Automaton automaton = alib::XmlDataFactory::fromTokens < automaton::Automaton > ( std::move ( tokens ) );
+			automaton::Automaton automaton = alib::XmlDataFactory::fromTokens ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -147,7 +147,7 @@ int main ( int argc, char * * argv ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( form.getValue ( ) == "CNF" ) {
-			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens < grammar::Grammar > ( std::move ( tokens ) );
+			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -159,7 +159,7 @@ int main ( int argc, char * * argv ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( form.getValue ( ) == "GNF" ) {
-			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens < grammar::Grammar > ( std::move ( tokens ) );
+			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -171,7 +171,7 @@ int main ( int argc, char * * argv ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( form.getValue ( ) == "LL1" ) {
-			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens < grammar::Grammar > ( std::move ( tokens ) );
+			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
diff --git a/aquery2/src/aquery.cpp b/aquery2/src/aquery.cpp
index e825f1a46e..a400703c4e 100644
--- a/aquery2/src/aquery.cpp
+++ b/aquery2/src/aquery.cpp
@@ -66,8 +66,8 @@ int main ( int argc, char * argv[] ) {
 		measurements::start ( "Input read", measurements::Type::AUXILIARY );
 
 		if ( query.getValue ( ) == "suffixTrieFactors" ) {
-			indexes::stringology::SuffixTrie < DefaultSymbolType > suffixTrie = alib::XmlDataFactory::fromTokens < indexes::stringology::SuffixTrie < DefaultSymbolType > > ( sax::FromXMLParserHelper::parseInput ( indexInput ) );
-			string::String pattern = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
+			indexes::stringology::SuffixTrie < DefaultSymbolType > suffixTrie = alib::XmlDataFactory::fromTokens ( sax::FromXMLParserHelper::parseInput ( indexInput ) );
+			string::String pattern = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -79,8 +79,8 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( query.getValue ( ) == "suffixArrayFactors" ) {
-			indexes::stringology::SuffixArray < > suffixArray = alib::XmlDataFactory::fromTokens < indexes::stringology::SuffixArray < > > ( sax::FromXMLParserHelper::parseInput ( indexInput ) );
-			string::String pattern = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
+			indexes::stringology::SuffixArray < > suffixArray = alib::XmlDataFactory::fromTokens ( sax::FromXMLParserHelper::parseInput ( indexInput ) );
+			string::String pattern = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -92,8 +92,8 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( query.getValue ( ) == "positionHeapFactors" ) {
-			indexes::stringology::PositionHeap < > positionHeap = alib::XmlDataFactory::fromTokens < indexes::stringology::PositionHeap < > > ( sax::FromXMLParserHelper::parseInput ( indexInput ) );
-			string::String pattern = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
+			indexes::stringology::PositionHeap < > positionHeap = alib::XmlDataFactory::fromTokens ( sax::FromXMLParserHelper::parseInput ( indexInput ) );
+			string::String pattern = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -105,8 +105,8 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( query.getValue ( ) == "bitParallelismFactors" ) {
-			indexes::stringology::BitParallelIndex < > bitParallelIndex = alib::XmlDataFactory::fromTokens < indexes::stringology::BitParallelIndex < > > ( sax::FromXMLParserHelper::parseInput ( indexInput ) );
-			string::String pattern = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
+			indexes::stringology::BitParallelIndex < > bitParallelIndex = alib::XmlDataFactory::fromTokens ( sax::FromXMLParserHelper::parseInput ( indexInput ) );
+			string::String pattern = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -118,8 +118,8 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( query.getValue ( ) == "compressedBitParallelismFactors" ) {
-			indexes::stringology::CompressedBitParallelIndex < > compressedBitParallelIndex = alib::XmlDataFactory::fromTokens < indexes::stringology::CompressedBitParallelIndex < > > ( sax::FromXMLParserHelper::parseInput ( indexInput ) );
-			string::String pattern = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
+			indexes::stringology::CompressedBitParallelIndex < > compressedBitParallelIndex = alib::XmlDataFactory::fromTokens ( sax::FromXMLParserHelper::parseInput ( indexInput ) );
+			string::String pattern = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -131,8 +131,8 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( query.getValue ( ) == "compressedBitParallelismPatterns" ) {
-			indexes::arbology::CompressedBitParallelTreeIndex < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > compressedBitParallelTreeIndex = alib::XmlDataFactory::fromTokens < indexes::arbology::CompressedBitParallelTreeIndex < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > > ( sax::FromXMLParserHelper::parseInput ( indexInput ) );
-			tree::RankedTreeWrapper pattern = alib::XmlDataFactory::fromTokens < tree::RankedTreeWrapper > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
+			indexes::arbology::CompressedBitParallelTreeIndex < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > compressedBitParallelTreeIndex = alib::XmlDataFactory::fromTokens ( sax::FromXMLParserHelper::parseInput ( indexInput ) );
+			tree::RankedTreeWrapper pattern = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -144,8 +144,8 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( query.getValue ( ) == "fullAndLinearIndexPatterns" ) {
-			indexes::arbology::FullAndLinearIndex < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > fullAndLinearIndex = alib::XmlDataFactory::fromTokens < indexes::arbology::FullAndLinearIndex < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > > ( sax::FromXMLParserHelper::parseInput ( indexInput ) );
-			tree::RankedTreeWrapper pattern = alib::XmlDataFactory::fromTokens < tree::RankedTreeWrapper > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
+			indexes::arbology::FullAndLinearIndex < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > fullAndLinearIndex = alib::XmlDataFactory::fromTokens ( sax::FromXMLParserHelper::parseInput ( indexInput ) );
+			tree::RankedTreeWrapper pattern = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
diff --git a/arand2/src/arand.cpp b/arand2/src/arand.cpp
index fe65ef0fd8..acc0ad2f9f 100644
--- a/arand2/src/arand.cpp
+++ b/arand2/src/arand.cpp
@@ -124,7 +124,7 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( type.getValue ( ) == "RFSM" ) {
-			automaton::Automaton baseAutomaton = alib::XmlDataFactory::fromTokens < automaton::Automaton > ( sax::FromXMLParserHelper::parseInput ( input ) );
+			automaton::Automaton baseAutomaton = alib::XmlDataFactory::fromTokens ( sax::FromXMLParserHelper::parseInput ( input ) );
 
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
 
@@ -148,7 +148,7 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( type.getValue ( ) == "RCFG" ) {
-			grammar::Grammar baseGrammar = alib::XmlDataFactory::fromTokens < grammar::Grammar > ( sax::FromXMLParserHelper::parseInput ( input ) );
+			grammar::Grammar baseGrammar = alib::XmlDataFactory::fromTokens ( sax::FromXMLParserHelper::parseInput ( input ) );
 
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
 
@@ -177,7 +177,7 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( type.getValue ( ) == "SST" ) {
-			string::String baseString = alib::XmlDataFactory::fromTokens < string::String > ( sax::FromXMLParserHelper::parseInput ( input ) );
+			string::String baseString = alib::XmlDataFactory::fromTokens ( sax::FromXMLParserHelper::parseInput ( input ) );
 
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
 
diff --git a/araw2/src/araw.cpp b/araw2/src/araw.cpp
index f0bbe20094..b5943fe225 100644
--- a/araw2/src/araw.cpp
+++ b/araw2/src/araw.cpp
@@ -76,7 +76,7 @@ int main(int argc, char** argv) {
 
 			alib::XmlDataFactory::toStdout(tree);
 		} else if(tree_to_raw.getValue()) {
-			tree::Tree tree = alib::XmlDataFactory::fromTokens<tree::Tree>(sax::FromXMLParserHelper::parseInput(input));
+			tree::Tree tree = alib::XmlDataFactory::fromTokens (sax::FromXMLParserHelper::parseInput(input));
 
 			measurements::end();
 			measurements::start("Output write", measurements::Type::AUXILIARY);
@@ -105,7 +105,7 @@ int main(int argc, char** argv) {
 
 			alib::XmlDataFactory::toStdout(string);
 		} else if(string_to_raw.getValue()) {
-			string::String string = alib::XmlDataFactory::fromTokens<string::String>(sax::FromXMLParserHelper::parseInput(input));
+			string::String string = alib::XmlDataFactory::fromTokens (sax::FromXMLParserHelper::parseInput(input));
 
 			measurements::end();
 			measurements::start("Output write", measurements::Type::AUXILIARY);
diff --git a/arename2/src/arename.cpp b/arename2/src/arename.cpp
index 44ffff8768..7738c376cd 100644
--- a/arename2/src/arename.cpp
+++ b/arename2/src/arename.cpp
@@ -45,7 +45,7 @@ int main ( int argc, char * * argv ) {
 		std::deque < sax::Token > tokens = sax::FromXMLParserHelper::parseInput ( input );
 
 		if ( alib::XmlDataFactory::first < automaton::Automaton > ( tokens ) ) {
-			automaton::Automaton automaton = alib::XmlDataFactory::fromTokens < automaton::Automaton > ( std::move ( tokens ) );
+			automaton::Automaton automaton = alib::XmlDataFactory::fromTokens ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -57,7 +57,7 @@ int main ( int argc, char * * argv ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( alib::XmlDataFactory::first < grammar::Grammar > ( tokens ) ) {
-			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens < grammar::Grammar > ( std::move ( tokens ) );
+			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
diff --git a/areverse2/src/areverse.cpp b/areverse2/src/areverse.cpp
index 2884225fa4..6b72d9e7e8 100644
--- a/areverse2/src/areverse.cpp
+++ b/areverse2/src/areverse.cpp
@@ -40,7 +40,7 @@ int main(int argc, char** argv) {
 		measurements::start("Overal", measurements::Type::OVERALL);
 		measurements::start("Input read", measurements::Type::AUXILIARY);
 
-		automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(sax::FromXMLParserHelper::parseInput(input));
+		automaton::Automaton automaton = alib::XmlDataFactory::fromTokens (sax::FromXMLParserHelper::parseInput(input));
 
 		measurements::end();
 		measurements::start("Algorithm", measurements::Type::MAIN);
diff --git a/arun2/src/arun.cpp b/arun2/src/arun.cpp
index 4fc1b6cc6f..adb7e66927 100644
--- a/arun2/src/arun.cpp
+++ b/arun2/src/arun.cpp
@@ -68,8 +68,8 @@ int main(int argc, char* argv[]) {
 		measurements::start("Overal", measurements::Type::OVERALL);
 		measurements::start("Input read", measurements::Type::AUXILIARY);
 
-		alib::Object inputData = alib::XmlDataFactory::fromTokens<alib::Object>(sax::FromXMLParserHelper::parseInput(input));
-		automaton::Automaton automatonData = alib::XmlDataFactory::fromTokens<automaton::Automaton>(sax::FromXMLParserHelper::parseInput(automaton));
+		alib::Object inputData = alib::XmlDataFactory::fromTokens (sax::FromXMLParserHelper::parseInput(input));
+		automaton::Automaton automatonData = alib::XmlDataFactory::fromTokens (sax::FromXMLParserHelper::parseInput(automaton));
 
 		measurements::end();
 		measurements::start("Algorithm", measurements::Type::MAIN);
@@ -89,7 +89,7 @@ int main(int argc, char* argv[]) {
 
 			alib::XmlDataFactory::toStdout( res );
 		} else if( type.getValue() == "result" && failState.isSet ( ) ) {
-			DefaultStateType failStateLabel = alib::XmlDataFactory::fromTokens<DefaultStateType>(sax::FromXMLParserHelper::parseInput(failState));
+			DefaultStateType failStateLabel = alib::XmlDataFactory::fromTokens (sax::FromXMLParserHelper::parseInput(failState));
 			DefaultStateType res = automaton::run::Result::result(automatonData, inputData, failStateLabel);
 
 			measurements::end();
diff --git a/astat2/src/astat.cpp b/astat2/src/astat.cpp
index fd75488b43..036f3fb567 100644
--- a/astat2/src/astat.cpp
+++ b/astat2/src/astat.cpp
@@ -64,7 +64,7 @@ int main ( int argc, char * argv[] ) {
 		std::deque < sax::Token > tokens = sax::FromXMLParserHelper::parseInput ( file );
 
 		if ( alib::XmlDataFactory::first < container::Container > ( tokens ) ) {
-			container::Container data = alib::XmlDataFactory::fromTokens < container::Container > ( std::move ( tokens ) );
+			container::Container data = alib::XmlDataFactory::fromTokens ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Stats print", measurements::Type::MAIN );
diff --git a/astringology2/src/astringology.cpp b/astringology2/src/astringology.cpp
index 2f9b7f12c9..119ddca609 100644
--- a/astringology2/src/astringology.cpp
+++ b/astringology2/src/astringology.cpp
@@ -96,8 +96,8 @@ int main ( int argc, char * argv[] ) {
 		measurements::start ( "Input read", measurements::Type::AUXILIARY );
 
 		if ( algorithm.getValue ( ) == "exactFactorMatch" ) {
-			string::String subject = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
-			string::String pattern = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
+			string::String subject = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			string::String pattern = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -109,8 +109,8 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( algorithm.getValue ( ) == "boyerMooreHorspool" ) {
-			string::String subject = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
-			string::String pattern = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
+			string::String subject = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			string::String pattern = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -122,8 +122,8 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( algorithm.getValue ( ) == "reversedBoyerMooreHorspool" ) {
-			string::String subject = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
-			string::String pattern = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
+			string::String subject = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			string::String pattern = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -135,8 +135,8 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( algorithm.getValue ( ) == "deadZoneUsingBadCharacterShift" ) {
-			string::String subject = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
-			string::String pattern = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
+			string::String subject = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			string::String pattern = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -148,8 +148,8 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( algorithm.getValue ( ) == "backwardNondeterministicDAWGMatching" ) {
-			string::String subject = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
-			string::String pattern = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
+			string::String subject = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			string::String pattern = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -161,8 +161,8 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( algorithm.getValue ( ) == "backwardOracleMatching" ) {
-			string::String subject = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
-			string::String pattern = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
+			string::String subject = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			string::String pattern = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -174,8 +174,8 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( algorithm.getValue ( ) == "backwardDAWGMatching" ) {
-			string::String subject = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
-			string::String pattern = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
+			string::String subject = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			string::String pattern = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -187,7 +187,7 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( algorithm.getValue ( ) == "exactMatchingAutomaton" ) {
-			string::String pattern = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
+			string::String pattern = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -199,7 +199,7 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( automaton );
 		} else if ( algorithm.getValue ( ) == "exactFactorAutomaton" ) {
-			string::String subject = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			string::String subject = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -211,7 +211,7 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( automaton );
 		} else if ( algorithm.getValue ( ) == "exactSubsequenceAutomaton" ) {
-			string::String subject = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			string::String subject = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -223,7 +223,7 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( automaton );
 		} else if ( algorithm.getValue ( ) == "exactNondeterministicSubsequenceAutomaton" ) {
-			string::String subject = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			string::String subject = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -237,8 +237,10 @@ int main ( int argc, char * argv[] ) {
 		} else if ( algorithm.getValue ( ) == "exactMultiNondeterministicSubsequenceAutomaton" ) {
 			std::set < string::String > subjects;
 
-			for ( std::deque < sax::Token > & tokens : sax::FromXMLParserHelper::parseInput(false, subjectInput) )
-				subjects.insert ( alib::XmlDataFactory::fromTokens < string::String > ( std::move ( tokens ) ) );
+			for ( std::deque < sax::Token > & tokens : sax::FromXMLParserHelper::parseInput(false, subjectInput) ) {
+				string::String string = alib::XmlDataFactory::fromTokens ( std::move ( tokens ) );
+				subjects.insert ( std::move ( string ) );
+			}
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -250,7 +252,7 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( automaton );
 		} else if ( algorithm.getValue ( ) == "factorOracleAutomaton" ) {
-			string::String pattern = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
+			string::String pattern = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -262,7 +264,7 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( automaton );
 		} else if ( algorithm.getValue ( ) == "suffixAutomaton" ) {
-			string::String pattern = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
+			string::String pattern = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -274,7 +276,7 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( automaton );
 		} else if ( algorithm.getValue ( ) == "borderArray" ) {
-			string::String subject = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			string::String subject = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -286,7 +288,7 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( borderArray );
 		} else if ( algorithm.getValue ( ) == "suffixTrie" ) {
-			string::String subject = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			string::String subject = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -298,7 +300,7 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( suffixTrie );
 		} else if ( algorithm.getValue ( ) == "positionHeap" ) {
-			string::String subject = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			string::String subject = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -310,7 +312,7 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( positionHeap );
 		} else if ( algorithm.getValue ( ) == "bitParallelIndex" ) {
-			string::String subject = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			string::String subject = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -322,7 +324,7 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( bitParallelIndex );
 		} else if ( algorithm.getValue ( ) == "compressedBitParallelIndex" ) {
-			string::String subject = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			string::String subject = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -334,7 +336,7 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( compressedBitParallelIndex );
 		} else if ( algorithm.getValue ( ) == "suffixArray" ) {
-			string::String subject = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			string::String subject = alib::XmlDataFactory::fromTokens ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
diff --git a/atrim2/src/atrim.cpp b/atrim2/src/atrim.cpp
index 01b0421849..06f914e4be 100644
--- a/atrim2/src/atrim.cpp
+++ b/atrim2/src/atrim.cpp
@@ -99,7 +99,7 @@ int main(int argc, char* argv[]) {
 		std::deque<sax::Token> tokens = sax::FromXMLParserHelper::parseInput(input);
 
 		if( alib::XmlDataFactory::first<automaton::Automaton>(tokens)) {
-			automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(std::move(tokens));
+			automaton::Automaton automaton = alib::XmlDataFactory::fromTokens (std::move(tokens));
 
 			measurements::end();
 			measurements::start("Algorithm", measurements::Type::MAIN);
@@ -120,7 +120,7 @@ int main(int argc, char* argv[]) {
 				alib::XmlDataFactory::toStdout( res );
 			}
 		} else if( alib::XmlDataFactory::first<grammar::Grammar>(tokens)) {
-			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens<grammar::Grammar>(std::move(tokens));
+			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens (std::move(tokens));
 
 			measurements::end();
 			measurements::start("Algorithm", measurements::Type::MAIN);
@@ -132,7 +132,7 @@ int main(int argc, char* argv[]) {
 
 			alib::XmlDataFactory::toStdout( res );
 		} else if( alib::XmlDataFactory::first<regexp::RegExp>(tokens)) {
-			regexp::RegExp regexp = alib::XmlDataFactory::fromTokens<regexp::RegExp>(std::move(tokens));
+			regexp::RegExp regexp = alib::XmlDataFactory::fromTokens (std::move(tokens));
 
 			measurements::end();
 			measurements::start("Algorithm", measurements::Type::MAIN);
diff --git a/tniceprint/src/tniceprint.cpp b/tniceprint/src/tniceprint.cpp
index e9cc0ac830..760b6fd312 100644
--- a/tniceprint/src/tniceprint.cpp
+++ b/tniceprint/src/tniceprint.cpp
@@ -45,14 +45,14 @@ int main(int argc, char** argv) {
 		std::deque<sax::Token> tokens = sax::FromXMLParserHelper::parseInput(input);
 
 		if (alib::XmlDataFactory::first<tree::RankedTree < > >(tokens)) {
-			tree::RankedTree < > tree = alib::XmlDataFactory::fromTokens<tree::RankedTree < > >(std::move(tokens));
+			tree::RankedTree < > tree = alib::XmlDataFactory::fromTokens (std::move(tokens));
 
 			measurements::end();
 			measurements::start("Output write", measurements::Type::AUXILIARY);
 
 			tree.nicePrint(std::cout);
 		} else if (alib::XmlDataFactory::first<tree::UnrankedTree < > >(tokens)) {
-			tree::UnrankedTree < > tree = alib::XmlDataFactory::fromTokens<tree::UnrankedTree < > >(std::move(tokens));
+			tree::UnrankedTree < > tree = alib::XmlDataFactory::fromTokens (std::move(tokens));
 
 			measurements::end();
 			measurements::start("Output write", measurements::Type::AUXILIARY);
-- 
GitLab