diff --git a/alib2common/src/measurements/MeasurementResultsXml.cpp b/alib2common/src/measurements/MeasurementResultsXml.cpp
index 81a7edd9c4b94c802c5f96a4181c076c66a2410c..945470c022a22a990d1fb5482c8128040712a285 100644
--- a/alib2common/src/measurements/MeasurementResultsXml.cpp
+++ b/alib2common/src/measurements/MeasurementResultsXml.cpp
@@ -6,36 +6,33 @@
 #include "MeasurementResultsXml.hpp"
 #include "../exception/CommonException.h"
 
-using namespace std;
-using namespace sax;
-
 namespace measurements {
 
-deque < Token > MeasurementResultsXml::compose ( const MeasurementResults & mr ) {
-	deque < Token > tokens;
+std::deque < sax::Token > MeasurementResultsXml::compose ( const MeasurementResults & mr ) {
+	std::deque < sax::Token > tokens;
 	compose ( mr, tokens );
 	return tokens;
 }
 
-void MeasurementResultsXml::compose ( const MeasurementResults & mr, deque < Token > & tokens ) {
-	tokens.emplace_back ( MEASUREMENT_RESULTS_TAG, Token::TokenType::START_ELEMENT );
+void MeasurementResultsXml::compose ( const MeasurementResults & mr, std::deque < sax::Token > & tokens ) {
+	tokens.emplace_back ( MEASUREMENT_RESULTS_TAG, sax::Token::TokenType::START_ELEMENT );
 
 	MeasurementResultsXml::composeMeasurementFrames ( tokens, 0, mr.frames );
 
-	tokens.emplace_back ( MEASUREMENT_RESULTS_TAG, Token::TokenType::END_ELEMENT );
+	tokens.emplace_back ( MEASUREMENT_RESULTS_TAG, sax::Token::TokenType::END_ELEMENT );
 }
 
-void MeasurementResultsXml::composeMeasurementFrames ( deque < Token > & tokens, unsigned idx, const stealth_vector < MeasurementFrame > & frames ) {
+void MeasurementResultsXml::composeMeasurementFrames ( std::deque < sax::Token > & tokens, unsigned idx, const stealth_vector < MeasurementFrame > & frames ) {
 
 	const MeasurementFrame & frame = frames[idx];
 
-	tokens.emplace_back ( MEASUREMENT_FRAME_TAG, Token::TokenType::START_ELEMENT );
-	tokens.emplace_back ( MEASUREMENT_FRAME_NAME_TAG, Token::TokenType::START_ELEMENT );
-	tokens.emplace_back ( measurements::to_string ( frame.name ), Token::TokenType::CHARACTER );
-	tokens.emplace_back ( MEASUREMENT_FRAME_NAME_TAG, Token::TokenType::END_ELEMENT );
-	tokens.emplace_back ( MEASUREMENT_FRAME_TYPE_TAG, Token::TokenType::START_ELEMENT );
-	tokens.emplace_back ( measurements::to_string ( frame.type ), Token::TokenType::CHARACTER );
-	tokens.emplace_back ( MEASUREMENT_FRAME_TYPE_TAG, Token::TokenType::END_ELEMENT );
+	tokens.emplace_back ( MEASUREMENT_FRAME_TAG, sax::Token::TokenType::START_ELEMENT );
+	tokens.emplace_back ( MEASUREMENT_FRAME_NAME_TAG, sax::Token::TokenType::START_ELEMENT );
+	tokens.emplace_back ( measurements::to_string ( frame.name ), sax::Token::TokenType::CHARACTER );
+	tokens.emplace_back ( MEASUREMENT_FRAME_NAME_TAG, sax::Token::TokenType::END_ELEMENT );
+	tokens.emplace_back ( MEASUREMENT_FRAME_TYPE_TAG, sax::Token::TokenType::START_ELEMENT );
+	tokens.emplace_back ( measurements::to_string ( frame.type ), sax::Token::TokenType::CHARACTER );
+	tokens.emplace_back ( MEASUREMENT_FRAME_TYPE_TAG, sax::Token::TokenType::END_ELEMENT );
 
 	if ( frame.type != measurements::Type::ROOT ) {
 		composeTimeDataFrame ( tokens, idx, frames );
@@ -43,130 +40,130 @@ void MeasurementResultsXml::composeMeasurementFrames ( deque < Token > & tokens,
 		composeCounterDataFrame ( tokens, idx, frames );
 	}
 
-	tokens.emplace_back ( MEASUREMENT_SUBFRAMES_TAG, Token::TokenType::START_ELEMENT );
+	tokens.emplace_back ( MEASUREMENT_SUBFRAMES_TAG, sax::Token::TokenType::START_ELEMENT );
 
 	for ( unsigned subIdx : frame.subIdxs )
 		composeMeasurementFrames ( tokens, subIdx, frames );
 
-	tokens.emplace_back ( MEASUREMENT_SUBFRAMES_TAG, Token::TokenType::END_ELEMENT );
+	tokens.emplace_back ( MEASUREMENT_SUBFRAMES_TAG, sax::Token::TokenType::END_ELEMENT );
 
-	tokens.emplace_back ( MEASUREMENT_FRAME_TAG, Token::TokenType::END_ELEMENT );
+	tokens.emplace_back ( MEASUREMENT_FRAME_TAG, sax::Token::TokenType::END_ELEMENT );
 }
 
-void MeasurementResultsXml::composeTimeDataFrame ( deque < Token > & tokens, unsigned idx, const stealth_vector < MeasurementFrame > & frames ) {
+void MeasurementResultsXml::composeTimeDataFrame ( std::deque < sax::Token > & tokens, unsigned idx, const stealth_vector < MeasurementFrame > & frames ) {
 	const TimeDataFrame & frame = frames[idx].time;
 
-	tokens.emplace_back ( TIME_DATA_FRAME_TAG, Token::TokenType::START_ELEMENT );
-	tokens.emplace_back ( TIME_DATA_FRAME_DURATION_TAG, Token::TokenType::START_ELEMENT );
-	tokens.emplace_back ( std::to_string ( frame.duration.count ( ) ), Token::TokenType::CHARACTER );
-	tokens.emplace_back ( TIME_DATA_FRAME_DURATION_TAG, Token::TokenType::END_ELEMENT );
-	tokens.emplace_back ( TIME_DATA_FRAME_IN_FRAME_DURATION_TAG, Token::TokenType::START_ELEMENT );
-	tokens.emplace_back ( std::to_string ( frame.inFrameDuration.count ( ) ), Token::TokenType::CHARACTER );
-	tokens.emplace_back ( TIME_DATA_FRAME_IN_FRAME_DURATION_TAG, Token::TokenType::END_ELEMENT );
-	tokens.emplace_back ( TIME_DATA_FRAME_TAG, Token::TokenType::END_ELEMENT );
+	tokens.emplace_back ( TIME_DATA_FRAME_TAG, sax::Token::TokenType::START_ELEMENT );
+	tokens.emplace_back ( TIME_DATA_FRAME_DURATION_TAG, sax::Token::TokenType::START_ELEMENT );
+	tokens.emplace_back ( std::to_string ( frame.duration.count ( ) ), sax::Token::TokenType::CHARACTER );
+	tokens.emplace_back ( TIME_DATA_FRAME_DURATION_TAG, sax::Token::TokenType::END_ELEMENT );
+	tokens.emplace_back ( TIME_DATA_FRAME_IN_FRAME_DURATION_TAG, sax::Token::TokenType::START_ELEMENT );
+	tokens.emplace_back ( std::to_string ( frame.inFrameDuration.count ( ) ), sax::Token::TokenType::CHARACTER );
+	tokens.emplace_back ( TIME_DATA_FRAME_IN_FRAME_DURATION_TAG, sax::Token::TokenType::END_ELEMENT );
+	tokens.emplace_back ( TIME_DATA_FRAME_TAG, sax::Token::TokenType::END_ELEMENT );
 }
 
-void MeasurementResultsXml::composeMemoryDataFrame ( deque < Token > & tokens, unsigned idx, const stealth_vector < MeasurementFrame > & frames ) {
+void MeasurementResultsXml::composeMemoryDataFrame ( std::deque < sax::Token > & tokens, unsigned idx, const stealth_vector < MeasurementFrame > & frames ) {
 	const MemoryDataFrame & frame = frames[idx].memory;
 
-	tokens.emplace_back ( MEMORY_DATA_FRAME_TAG, Token::TokenType::START_ELEMENT );
-	tokens.emplace_back ( MEMORY_DATA_FRAME_START_HEAP_USAGE_TAG, Token::TokenType::START_ELEMENT );
-	tokens.emplace_back ( std::to_string ( frame.startHeapUsage ), Token::TokenType::CHARACTER );
-	tokens.emplace_back ( MEMORY_DATA_FRAME_START_HEAP_USAGE_TAG, Token::TokenType::END_ELEMENT );
-	tokens.emplace_back ( MEMORY_DATA_FRAME_END_HEAP_USAGE_TAG, Token::TokenType::START_ELEMENT );
-	tokens.emplace_back ( std::to_string ( frame.endHeapUsage ), Token::TokenType::CHARACTER );
-	tokens.emplace_back ( MEMORY_DATA_FRAME_END_HEAP_USAGE_TAG, Token::TokenType::END_ELEMENT );
-	tokens.emplace_back ( MEMORY_DATA_FRAME_HIGH_WATERMARK_TAG, Token::TokenType::START_ELEMENT );
-	tokens.emplace_back ( std::to_string ( frame.highWatermark ), Token::TokenType::CHARACTER );
-	tokens.emplace_back ( MEMORY_DATA_FRAME_HIGH_WATERMARK_TAG, Token::TokenType::END_ELEMENT );
-	tokens.emplace_back ( MEMORY_DATA_FRAME_IN_FRAME_HIGH_WATERMARK_TAG, Token::TokenType::START_ELEMENT );
-	tokens.emplace_back ( std::to_string ( frame.inFrameHighWatermark ), Token::TokenType::CHARACTER );
-	tokens.emplace_back ( MEMORY_DATA_FRAME_IN_FRAME_HIGH_WATERMARK_TAG, Token::TokenType::END_ELEMENT );
-	tokens.emplace_back ( MEMORY_DATA_FRAME_TAG, Token::TokenType::END_ELEMENT );
+	tokens.emplace_back ( MEMORY_DATA_FRAME_TAG, sax::Token::TokenType::START_ELEMENT );
+	tokens.emplace_back ( MEMORY_DATA_FRAME_START_HEAP_USAGE_TAG, sax::Token::TokenType::START_ELEMENT );
+	tokens.emplace_back ( std::to_string ( frame.startHeapUsage ), sax::Token::TokenType::CHARACTER );
+	tokens.emplace_back ( MEMORY_DATA_FRAME_START_HEAP_USAGE_TAG, sax::Token::TokenType::END_ELEMENT );
+	tokens.emplace_back ( MEMORY_DATA_FRAME_END_HEAP_USAGE_TAG, sax::Token::TokenType::START_ELEMENT );
+	tokens.emplace_back ( std::to_string ( frame.endHeapUsage ), sax::Token::TokenType::CHARACTER );
+	tokens.emplace_back ( MEMORY_DATA_FRAME_END_HEAP_USAGE_TAG, sax::Token::TokenType::END_ELEMENT );
+	tokens.emplace_back ( MEMORY_DATA_FRAME_HIGH_WATERMARK_TAG, sax::Token::TokenType::START_ELEMENT );
+	tokens.emplace_back ( std::to_string ( frame.highWatermark ), sax::Token::TokenType::CHARACTER );
+	tokens.emplace_back ( MEMORY_DATA_FRAME_HIGH_WATERMARK_TAG, sax::Token::TokenType::END_ELEMENT );
+	tokens.emplace_back ( MEMORY_DATA_FRAME_IN_FRAME_HIGH_WATERMARK_TAG, sax::Token::TokenType::START_ELEMENT );
+	tokens.emplace_back ( std::to_string ( frame.inFrameHighWatermark ), sax::Token::TokenType::CHARACTER );
+	tokens.emplace_back ( MEMORY_DATA_FRAME_IN_FRAME_HIGH_WATERMARK_TAG, sax::Token::TokenType::END_ELEMENT );
+	tokens.emplace_back ( MEMORY_DATA_FRAME_TAG, sax::Token::TokenType::END_ELEMENT );
 }
 
-void MeasurementResultsXml::composeCounterDataFrame ( deque < Token > & tokens, unsigned idx, const stealth_vector < MeasurementFrame > & frames ) {
+void MeasurementResultsXml::composeCounterDataFrame ( std::deque < sax::Token > & tokens, unsigned idx, const stealth_vector < MeasurementFrame > & frames ) {
 	const CounterDataFrame & cdf = frames[idx].counter;
 
-	tokens.emplace_back ( COUNTER_DATA_FRAME_TAG, Token::TokenType::START_ELEMENT );
+	tokens.emplace_back ( COUNTER_DATA_FRAME_TAG, sax::Token::TokenType::START_ELEMENT );
 
-	tokens.emplace_back ( COUNTER_DATA_FRAME_COUNTERS_TAG, Token::TokenType::START_ELEMENT );
+	tokens.emplace_back ( COUNTER_DATA_FRAME_COUNTERS_TAG, sax::Token::TokenType::START_ELEMENT );
 
 	for ( const auto & elem : cdf.counters ) {
-		tokens.emplace_back ( COUNTER_DATA_FRAME_COUNTER_TAG, Token::TokenType::START_ELEMENT );
-		tokens.emplace_back ( COUNTER_DATA_FRAME_COUNTER_NAME_TAG, Token::TokenType::START_ELEMENT );
-		tokens.emplace_back ( measurements::to_string ( elem.first ), Token::TokenType::CHARACTER );
-		tokens.emplace_back ( COUNTER_DATA_FRAME_COUNTER_NAME_TAG, Token::TokenType::END_ELEMENT );
-		tokens.emplace_back ( COUNTER_DATA_FRAME_COUNTER_VALUE_TAG, Token::TokenType::START_ELEMENT );
-		tokens.emplace_back ( std::to_string ( elem.second ), Token::TokenType::CHARACTER );
-		tokens.emplace_back ( COUNTER_DATA_FRAME_COUNTER_VALUE_TAG, Token::TokenType::END_ELEMENT );
-		tokens.emplace_back ( COUNTER_DATA_FRAME_COUNTER_TAG, Token::TokenType::END_ELEMENT );
+		tokens.emplace_back ( COUNTER_DATA_FRAME_COUNTER_TAG, sax::Token::TokenType::START_ELEMENT );
+		tokens.emplace_back ( COUNTER_DATA_FRAME_COUNTER_NAME_TAG, sax::Token::TokenType::START_ELEMENT );
+		tokens.emplace_back ( measurements::to_string ( elem.first ), sax::Token::TokenType::CHARACTER );
+		tokens.emplace_back ( COUNTER_DATA_FRAME_COUNTER_NAME_TAG, sax::Token::TokenType::END_ELEMENT );
+		tokens.emplace_back ( COUNTER_DATA_FRAME_COUNTER_VALUE_TAG, sax::Token::TokenType::START_ELEMENT );
+		tokens.emplace_back ( std::to_string ( elem.second ), sax::Token::TokenType::CHARACTER );
+		tokens.emplace_back ( COUNTER_DATA_FRAME_COUNTER_VALUE_TAG, sax::Token::TokenType::END_ELEMENT );
+		tokens.emplace_back ( COUNTER_DATA_FRAME_COUNTER_TAG, sax::Token::TokenType::END_ELEMENT );
 	}
 
-	tokens.emplace_back ( COUNTER_DATA_FRAME_COUNTERS_TAG, Token::TokenType::END_ELEMENT );
+	tokens.emplace_back ( COUNTER_DATA_FRAME_COUNTERS_TAG, sax::Token::TokenType::END_ELEMENT );
 
-	tokens.emplace_back ( COUNTER_DATA_FRAME_IN_FRAME_COUNTERS_TAG, Token::TokenType::START_ELEMENT );
+	tokens.emplace_back ( COUNTER_DATA_FRAME_IN_FRAME_COUNTERS_TAG, sax::Token::TokenType::START_ELEMENT );
 
 	for ( const auto & elem : cdf.inFrameCounters ) {
-		tokens.emplace_back ( COUNTER_DATA_FRAME_COUNTER_TAG, Token::TokenType::START_ELEMENT );
-		tokens.emplace_back ( COUNTER_DATA_FRAME_COUNTER_NAME_TAG, Token::TokenType::START_ELEMENT );
-		tokens.emplace_back ( measurements::to_string ( elem.first ), Token::TokenType::CHARACTER );
-		tokens.emplace_back ( COUNTER_DATA_FRAME_COUNTER_NAME_TAG, Token::TokenType::END_ELEMENT );
-		tokens.emplace_back ( COUNTER_DATA_FRAME_COUNTER_VALUE_TAG, Token::TokenType::START_ELEMENT );
-		tokens.emplace_back ( std::to_string ( elem.second ), Token::TokenType::CHARACTER );
-		tokens.emplace_back ( COUNTER_DATA_FRAME_COUNTER_VALUE_TAG, Token::TokenType::END_ELEMENT );
-		tokens.emplace_back ( COUNTER_DATA_FRAME_COUNTER_TAG, Token::TokenType::END_ELEMENT );
+		tokens.emplace_back ( COUNTER_DATA_FRAME_COUNTER_TAG, sax::Token::TokenType::START_ELEMENT );
+		tokens.emplace_back ( COUNTER_DATA_FRAME_COUNTER_NAME_TAG, sax::Token::TokenType::START_ELEMENT );
+		tokens.emplace_back ( measurements::to_string ( elem.first ), sax::Token::TokenType::CHARACTER );
+		tokens.emplace_back ( COUNTER_DATA_FRAME_COUNTER_NAME_TAG, sax::Token::TokenType::END_ELEMENT );
+		tokens.emplace_back ( COUNTER_DATA_FRAME_COUNTER_VALUE_TAG, sax::Token::TokenType::START_ELEMENT );
+		tokens.emplace_back ( std::to_string ( elem.second ), sax::Token::TokenType::CHARACTER );
+		tokens.emplace_back ( COUNTER_DATA_FRAME_COUNTER_VALUE_TAG, sax::Token::TokenType::END_ELEMENT );
+		tokens.emplace_back ( COUNTER_DATA_FRAME_COUNTER_TAG, sax::Token::TokenType::END_ELEMENT );
 	}
 
-	tokens.emplace_back ( COUNTER_DATA_FRAME_IN_FRAME_COUNTERS_TAG, Token::TokenType::END_ELEMENT );
+	tokens.emplace_back ( COUNTER_DATA_FRAME_IN_FRAME_COUNTERS_TAG, sax::Token::TokenType::END_ELEMENT );
 
-	tokens.emplace_back ( COUNTER_DATA_FRAME_TAG, Token::TokenType::END_ELEMENT );
+	tokens.emplace_back ( COUNTER_DATA_FRAME_TAG, sax::Token::TokenType::END_ELEMENT );
 }
 
-MeasurementResults MeasurementResultsXml::parse ( deque < Token > & tokens ) {
+MeasurementResults MeasurementResultsXml::parse ( std::deque < sax::Token > & tokens ) {
 	MeasurementResults mr;
 
-	deque < Token >::iterator iter = tokens.begin ( );
+	std::deque < sax::Token >::iterator iter = tokens.begin ( );
 
 	if ( iter == tokens.end ( ) ) throw::exception::CommonException ( "Empty tokens list" );
 
 	mr = parse ( iter );
 
-	if ( iter != tokens.end ( ) ) throw::exception::CommonException ( "Unexpeted tokens at the end of the xml" );
+	if ( iter != tokens.end ( ) ) throw::exception::CommonException ( "Unexpected tokens at the end of the xml" );
 
 	return mr;
 }
 
-MeasurementResults MeasurementResultsXml::parse ( deque < Token >::iterator & iter ) {
+MeasurementResults MeasurementResultsXml::parse ( std::deque < sax::Token >::iterator & iter ) {
 	MeasurementResults mr;
 
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, MEASUREMENT_RESULTS_TAG );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, MEASUREMENT_RESULTS_TAG );
 
 	parseRootMeasurementFrame ( mr, iter );
 
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, MEASUREMENT_RESULTS_TAG );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, MEASUREMENT_RESULTS_TAG );
 
 	return mr;
 }
 
-void MeasurementResultsXml::parseRootMeasurementFrame ( MeasurementResults & mr, deque < Token >::iterator & iter ) {
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, MEASUREMENT_FRAME_TAG );
+void MeasurementResultsXml::parseRootMeasurementFrame ( MeasurementResults & mr, std::deque < sax::Token >::iterator & iter ) {
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, MEASUREMENT_FRAME_TAG );
 
 	mr.frames.emplace_back ( "Root", measurements::Type::ROOT, 0 );
 
 	for ( ; ; ) {
-		if ( !FromXMLParserHelper::isTokenType ( iter, Token::TokenType::START_ELEMENT ) ) break;
+		if ( !sax::FromXMLParserHelper::isTokenType ( iter, sax::Token::TokenType::START_ELEMENT ) ) break;
 
-		string data = FromXMLParserHelper::getTokenData ( iter, Token::TokenType::START_ELEMENT );
+		std::string data = sax::FromXMLParserHelper::getTokenData ( iter, sax::Token::TokenType::START_ELEMENT );
 
 		if ( data == MEASUREMENT_FRAME_NAME_TAG ) {
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, MEASUREMENT_FRAME_NAME_TAG );
-			FromXMLParserHelper::popTokenData ( iter, Token::TokenType::CHARACTER );
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, MEASUREMENT_FRAME_NAME_TAG );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, MEASUREMENT_FRAME_NAME_TAG );
+			sax::FromXMLParserHelper::popTokenData ( iter, sax::Token::TokenType::CHARACTER );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, MEASUREMENT_FRAME_NAME_TAG );
 		} else if ( data == MEASUREMENT_FRAME_TYPE_TAG ) {
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, MEASUREMENT_FRAME_TYPE_TAG );
-			FromXMLParserHelper::popTokenData ( iter, Token::TokenType::CHARACTER );
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, MEASUREMENT_FRAME_TYPE_TAG );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, MEASUREMENT_FRAME_TYPE_TAG );
+			sax::FromXMLParserHelper::popTokenData ( iter, sax::Token::TokenType::CHARACTER );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, MEASUREMENT_FRAME_TYPE_TAG );
 		} else if ( data == MEASUREMENT_SUBFRAMES_TAG ) {
 
 			parseSubframes ( 0, mr, iter );
@@ -175,16 +172,16 @@ void MeasurementResultsXml::parseRootMeasurementFrame ( MeasurementResults & mr,
 		}
 	}
 
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, MEASUREMENT_FRAME_TAG );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, MEASUREMENT_FRAME_TAG );
 }
 
-void MeasurementResultsXml::parseSubframes ( unsigned parentIdx, MeasurementResults & mr, deque < Token >::iterator & iter ) {
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, MEASUREMENT_SUBFRAMES_TAG );
+void MeasurementResultsXml::parseSubframes ( unsigned parentIdx, MeasurementResults & mr, std::deque < sax::Token >::iterator & iter ) {
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, MEASUREMENT_SUBFRAMES_TAG );
 
 	for ( ; ; ) {
-		if ( !FromXMLParserHelper::isTokenType ( iter, Token::TokenType::START_ELEMENT ) ) break;
+		if ( !sax::FromXMLParserHelper::isTokenType ( iter, sax::Token::TokenType::START_ELEMENT ) ) break;
 
-		string data = FromXMLParserHelper::getTokenData ( iter, Token::TokenType::START_ELEMENT );
+		std::string data = sax::FromXMLParserHelper::getTokenData ( iter, sax::Token::TokenType::START_ELEMENT );
 
 		if ( data == MEASUREMENT_FRAME_TAG )
 			parseMeasurementFrame ( parentIdx, mr, iter );
@@ -192,11 +189,11 @@ void MeasurementResultsXml::parseSubframes ( unsigned parentIdx, MeasurementResu
 			break;
 	}
 
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, MEASUREMENT_SUBFRAMES_TAG );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, MEASUREMENT_SUBFRAMES_TAG );
 }
 
-void MeasurementResultsXml::parseMeasurementFrame ( unsigned parentIdx, MeasurementResults & mr, deque < Token >::iterator & iter ) {
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, MEASUREMENT_FRAME_TAG );
+void MeasurementResultsXml::parseMeasurementFrame ( unsigned parentIdx, MeasurementResults & mr, std::deque < sax::Token >::iterator & iter ) {
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, MEASUREMENT_FRAME_TAG );
 
 	unsigned mfIdx = mr.frames.size ( );
 
@@ -206,18 +203,18 @@ void MeasurementResultsXml::parseMeasurementFrame ( unsigned parentIdx, Measurem
 	mr.frames[parentIdx].subIdxs.push_back ( mfIdx );
 
 	for ( ; ; ) {
-		if ( !FromXMLParserHelper::isTokenType ( iter, Token::TokenType::START_ELEMENT ) ) break;
+		if ( !sax::FromXMLParserHelper::isTokenType ( iter, sax::Token::TokenType::START_ELEMENT ) ) break;
 
-		string data = FromXMLParserHelper::getTokenData ( iter, Token::TokenType::START_ELEMENT );
+		std::string data = sax::FromXMLParserHelper::getTokenData ( iter, sax::Token::TokenType::START_ELEMENT );
 
 		if ( data == MEASUREMENT_FRAME_NAME_TAG ) {
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, MEASUREMENT_FRAME_NAME_TAG );
-			mf.name = measurements::stealthStringFromString ( FromXMLParserHelper::popTokenData ( iter, Token::TokenType::CHARACTER ) );
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, MEASUREMENT_FRAME_NAME_TAG );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, MEASUREMENT_FRAME_NAME_TAG );
+			mf.name = measurements::stealthStringFromString ( sax::FromXMLParserHelper::popTokenData ( iter, sax::Token::TokenType::CHARACTER ) );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, MEASUREMENT_FRAME_NAME_TAG );
 		} else if ( data == MEASUREMENT_FRAME_TYPE_TAG ) {
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, MEASUREMENT_FRAME_TYPE_TAG );
-			mf.type = measurements::measurementTypeFromString ( FromXMLParserHelper::popTokenData ( iter, Token::TokenType::CHARACTER ) );
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, MEASUREMENT_FRAME_TYPE_TAG );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, MEASUREMENT_FRAME_TYPE_TAG );
+			mf.type = measurements::measurementTypeFromString ( sax::FromXMLParserHelper::popTokenData ( iter, sax::Token::TokenType::CHARACTER ) );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, MEASUREMENT_FRAME_TYPE_TAG );
 		} else if ( data == TIME_DATA_FRAME_TAG ) {
 			parseTimeDataFrame ( mf, iter );
 		} else if ( data == MEMORY_DATA_FRAME_TAG ) {
@@ -231,72 +228,72 @@ void MeasurementResultsXml::parseMeasurementFrame ( unsigned parentIdx, Measurem
 		}
 	}
 
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, MEASUREMENT_FRAME_TAG );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, MEASUREMENT_FRAME_TAG );
 }
 
-void MeasurementResultsXml::parseTimeDataFrame ( MeasurementFrame & mf, deque < Token >::iterator & iter ) {
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, TIME_DATA_FRAME_TAG );
+void MeasurementResultsXml::parseTimeDataFrame ( MeasurementFrame & mf, std::deque < sax::Token >::iterator & iter ) {
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, TIME_DATA_FRAME_TAG );
 
 	for ( ; ; ) {
-		if ( !FromXMLParserHelper::isTokenType ( iter, Token::TokenType::START_ELEMENT ) ) break;
+		if ( !sax::FromXMLParserHelper::isTokenType ( iter, sax::Token::TokenType::START_ELEMENT ) ) break;
 
-		string data = FromXMLParserHelper::getTokenData ( iter, Token::TokenType::START_ELEMENT );
+		std::string data = sax::FromXMLParserHelper::getTokenData ( iter, sax::Token::TokenType::START_ELEMENT );
 
 		if ( data == TIME_DATA_FRAME_DURATION_TAG ) {
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, TIME_DATA_FRAME_DURATION_TAG );
-			mf.time.duration = TimeDataFrame::value_type ( valueTypeFromString < TimeDataFrame::value_type::rep > ( FromXMLParserHelper::popTokenData ( iter, Token::TokenType::CHARACTER ) ) );
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, TIME_DATA_FRAME_DURATION_TAG );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, TIME_DATA_FRAME_DURATION_TAG );
+			mf.time.duration = TimeDataFrame::value_type ( valueTypeFromString < TimeDataFrame::value_type::rep > ( sax::FromXMLParserHelper::popTokenData ( iter, sax::Token::TokenType::CHARACTER ) ) );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, TIME_DATA_FRAME_DURATION_TAG );
 		} else if ( data == TIME_DATA_FRAME_IN_FRAME_DURATION_TAG ) {
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, TIME_DATA_FRAME_IN_FRAME_DURATION_TAG );
-			mf.time.inFrameDuration = TimeDataFrame::value_type ( valueTypeFromString < TimeDataFrame::value_type::rep > ( FromXMLParserHelper::popTokenData ( iter, Token::TokenType::CHARACTER ) ) );
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, TIME_DATA_FRAME_IN_FRAME_DURATION_TAG );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, TIME_DATA_FRAME_IN_FRAME_DURATION_TAG );
+			mf.time.inFrameDuration = TimeDataFrame::value_type ( valueTypeFromString < TimeDataFrame::value_type::rep > ( sax::FromXMLParserHelper::popTokenData ( iter, sax::Token::TokenType::CHARACTER ) ) );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, TIME_DATA_FRAME_IN_FRAME_DURATION_TAG );
 		} else {
 			break;
 		}
 	}
 
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, TIME_DATA_FRAME_TAG );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, TIME_DATA_FRAME_TAG );
 }
 
-void MeasurementResultsXml::parseMemoryDataFrame ( MeasurementFrame & mf, deque < Token >::iterator & iter ) {
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, MEMORY_DATA_FRAME_TAG );
+void MeasurementResultsXml::parseMemoryDataFrame ( MeasurementFrame & mf, std::deque < sax::Token >::iterator & iter ) {
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, MEMORY_DATA_FRAME_TAG );
 
 	for ( ; ; ) {
-		if ( !FromXMLParserHelper::isTokenType ( iter, Token::TokenType::START_ELEMENT ) ) break;
+		if ( !sax::FromXMLParserHelper::isTokenType ( iter, sax::Token::TokenType::START_ELEMENT ) ) break;
 
-		string data = FromXMLParserHelper::getTokenData ( iter, Token::TokenType::START_ELEMENT );
+		std::string data = sax::FromXMLParserHelper::getTokenData ( iter, sax::Token::TokenType::START_ELEMENT );
 
 		if ( data == MEMORY_DATA_FRAME_START_HEAP_USAGE_TAG ) {
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, MEMORY_DATA_FRAME_START_HEAP_USAGE_TAG );
-			mf.memory.startHeapUsage = valueTypeFromString < MemoryDataFrame::value_type > ( FromXMLParserHelper::popTokenData ( iter, Token::TokenType::CHARACTER ) );
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, MEMORY_DATA_FRAME_START_HEAP_USAGE_TAG );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, MEMORY_DATA_FRAME_START_HEAP_USAGE_TAG );
+			mf.memory.startHeapUsage = valueTypeFromString < MemoryDataFrame::value_type > ( sax::FromXMLParserHelper::popTokenData ( iter, sax::Token::TokenType::CHARACTER ) );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, MEMORY_DATA_FRAME_START_HEAP_USAGE_TAG );
 		} else if ( data == MEMORY_DATA_FRAME_END_HEAP_USAGE_TAG ) {
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, MEMORY_DATA_FRAME_END_HEAP_USAGE_TAG );
-			mf.memory.endHeapUsage = valueTypeFromString < MemoryDataFrame::value_type > ( FromXMLParserHelper::popTokenData ( iter, Token::TokenType::CHARACTER ) );
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, MEMORY_DATA_FRAME_END_HEAP_USAGE_TAG );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, MEMORY_DATA_FRAME_END_HEAP_USAGE_TAG );
+			mf.memory.endHeapUsage = valueTypeFromString < MemoryDataFrame::value_type > ( sax::FromXMLParserHelper::popTokenData ( iter, sax::Token::TokenType::CHARACTER ) );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, MEMORY_DATA_FRAME_END_HEAP_USAGE_TAG );
 		} else if ( data == MEMORY_DATA_FRAME_HIGH_WATERMARK_TAG ) {
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, MEMORY_DATA_FRAME_HIGH_WATERMARK_TAG );
-			mf.memory.highWatermark = valueTypeFromString < MemoryDataFrame::value_type > ( FromXMLParserHelper::popTokenData ( iter, Token::TokenType::CHARACTER ) );
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, MEMORY_DATA_FRAME_HIGH_WATERMARK_TAG );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, MEMORY_DATA_FRAME_HIGH_WATERMARK_TAG );
+			mf.memory.highWatermark = valueTypeFromString < MemoryDataFrame::value_type > ( sax::FromXMLParserHelper::popTokenData ( iter, sax::Token::TokenType::CHARACTER ) );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, MEMORY_DATA_FRAME_HIGH_WATERMARK_TAG );
 		} else if ( data == MEMORY_DATA_FRAME_IN_FRAME_HIGH_WATERMARK_TAG ) {
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, MEMORY_DATA_FRAME_IN_FRAME_HIGH_WATERMARK_TAG );
-			mf.memory.inFrameHighWatermark = valueTypeFromString < MemoryDataFrame::value_type > ( FromXMLParserHelper::popTokenData ( iter, Token::TokenType::CHARACTER ) );
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, MEMORY_DATA_FRAME_IN_FRAME_HIGH_WATERMARK_TAG );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, MEMORY_DATA_FRAME_IN_FRAME_HIGH_WATERMARK_TAG );
+			mf.memory.inFrameHighWatermark = valueTypeFromString < MemoryDataFrame::value_type > ( sax::FromXMLParserHelper::popTokenData ( iter, sax::Token::TokenType::CHARACTER ) );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, MEMORY_DATA_FRAME_IN_FRAME_HIGH_WATERMARK_TAG );
 		} else {
 			break;
 		}
 	}
 
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, MEMORY_DATA_FRAME_TAG );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, MEMORY_DATA_FRAME_TAG );
 }
 
-void MeasurementResultsXml::parseCounterDataFrame ( MeasurementFrame & mf, deque < Token >::iterator & iter ) {
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, COUNTER_DATA_FRAME_TAG );
+void MeasurementResultsXml::parseCounterDataFrame ( MeasurementFrame & mf, std::deque < sax::Token >::iterator & iter ) {
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, COUNTER_DATA_FRAME_TAG );
 
 	for ( ; ; ) {
-		if ( !FromXMLParserHelper::isTokenType ( iter, Token::TokenType::START_ELEMENT ) ) break;
+		if ( !sax::FromXMLParserHelper::isTokenType ( iter, sax::Token::TokenType::START_ELEMENT ) ) break;
 
-		string data = FromXMLParserHelper::getTokenData ( iter, Token::TokenType::START_ELEMENT );
+		std::string data = sax::FromXMLParserHelper::getTokenData ( iter, sax::Token::TokenType::START_ELEMENT );
 
 		if ( data == COUNTER_DATA_FRAME_COUNTERS_TAG )
 			parseCounterDataFrameCounters ( COUNTER_DATA_FRAME_COUNTERS_TAG, mf.counter.counters, iter );
@@ -306,42 +303,42 @@ void MeasurementResultsXml::parseCounterDataFrame ( MeasurementFrame & mf, deque
 			break;
 	}
 
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, COUNTER_DATA_FRAME_TAG );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, COUNTER_DATA_FRAME_TAG );
 }
 
 void MeasurementResultsXml::parseCounterDataFrameCounters ( const std::string & tag, stealth_map < stealth_string, CounterHint::value_type > & counters, std::deque < sax::Token >::iterator & iter ) {
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, tag );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, tag );
 
 	for ( ; ; ) {
-		if ( !FromXMLParserHelper::isTokenType ( iter, Token::TokenType::START_ELEMENT ) ) break;
+		if ( !sax::FromXMLParserHelper::isTokenType ( iter, sax::Token::TokenType::START_ELEMENT ) ) break;
 
-		string data = FromXMLParserHelper::getTokenData ( iter, Token::TokenType::START_ELEMENT );
+		std::string data = sax::FromXMLParserHelper::getTokenData ( iter, sax::Token::TokenType::START_ELEMENT );
 
 		if ( data == COUNTER_DATA_FRAME_COUNTER_TAG ) {
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, COUNTER_DATA_FRAME_COUNTER_TAG );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, COUNTER_DATA_FRAME_COUNTER_TAG );
 
 			stealth_string counterName;
 			CounterHint::value_type counterValue = { };
 
 			for ( ; ; ) {
-				if ( !FromXMLParserHelper::isTokenType ( iter, Token::TokenType::START_ELEMENT ) ) break;
+				if ( !sax::FromXMLParserHelper::isTokenType ( iter, sax::Token::TokenType::START_ELEMENT ) ) break;
 
-				string counterData = FromXMLParserHelper::getTokenData ( iter, Token::TokenType::START_ELEMENT );
+				std::string counterData = sax::FromXMLParserHelper::getTokenData ( iter, sax::Token::TokenType::START_ELEMENT );
 
 				if ( counterData == COUNTER_DATA_FRAME_COUNTER_NAME_TAG ) {
-					FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, COUNTER_DATA_FRAME_COUNTER_NAME_TAG );
-					counterName = stealthStringFromString ( FromXMLParserHelper::popTokenData ( iter, Token::TokenType::CHARACTER ) );
-					FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, COUNTER_DATA_FRAME_COUNTER_NAME_TAG );
+					sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, COUNTER_DATA_FRAME_COUNTER_NAME_TAG );
+					counterName = stealthStringFromString ( sax::FromXMLParserHelper::popTokenData ( iter, sax::Token::TokenType::CHARACTER ) );
+					sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, COUNTER_DATA_FRAME_COUNTER_NAME_TAG );
 				} else if ( counterData == COUNTER_DATA_FRAME_COUNTER_VALUE_TAG ) {
-					FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, COUNTER_DATA_FRAME_COUNTER_VALUE_TAG );
-					counterValue = valueTypeFromString < CounterHint::value_type > ( FromXMLParserHelper::popTokenData ( iter, Token::TokenType::CHARACTER ) );
-					FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, COUNTER_DATA_FRAME_COUNTER_VALUE_TAG );
+					sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, COUNTER_DATA_FRAME_COUNTER_VALUE_TAG );
+					counterValue = valueTypeFromString < CounterHint::value_type > ( sax::FromXMLParserHelper::popTokenData ( iter, sax::Token::TokenType::CHARACTER ) );
+					sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, COUNTER_DATA_FRAME_COUNTER_VALUE_TAG );
 				} else {
 					break;
 				}
 			}
 
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, COUNTER_DATA_FRAME_COUNTER_TAG );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, COUNTER_DATA_FRAME_COUNTER_TAG );
 
 			counters[counterName] = counterValue;
 
@@ -350,12 +347,12 @@ void MeasurementResultsXml::parseCounterDataFrameCounters ( const std::string &
 		}
 	}
 
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, tag );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, tag );
 }
 
 template < typename T >
 T MeasurementResultsXml::valueTypeFromString ( const std::string & str ) {
-	istringstream iss ( str );
+	std::istringstream iss ( str );
 	T val;
 
 	iss >> val;
diff --git a/alib2measurepp/src/provisioner/MeasurementProvisioner.cpp b/alib2measurepp/src/provisioner/MeasurementProvisioner.cpp
index d0108a5a37cdddbbba4a4572277f9927c8ad526c..c548fc925b5ce4d4213adff1dfbb9b198b80ba67 100644
--- a/alib2measurepp/src/provisioner/MeasurementProvisioner.cpp
+++ b/alib2measurepp/src/provisioner/MeasurementProvisioner.cpp
@@ -10,19 +10,17 @@
 
 #include "MeasurementProvisionerUtils.hpp"
 
-using namespace std;
-
 namespace measurements {
 
 MeasurementProvisionerResults MeasurementProvisioner::runConfiguration ( const MeasurementProvisionerConfiguration & cfg ) {
 
 	prepareEnvironment ( cfg );
 
-	clog << "Preparing data ..." << flush;
+	std::clog << "Preparing data ..." << std::flush;
 
 	MPInputData mpiData ( cfg );
 
-	clog << " done!" << endl;
+	std::clog << " done!" << std::endl;
 
 	MeasurementProvisionerResults mpr;
 
@@ -36,24 +34,24 @@ MeasurementProvisionerResults MeasurementProvisioner::runConfiguration ( const M
 			mprir.inputs.push_back ( { mpsmPair.first, mpiData.getMPIDHandle ( mpsmPair.second ).alias } );
 
 		if ( inputCounter != 1 )
-			clog << endl << endl;
+			std::clog << std::endl << std::endl;
 
-		clog << "+" << endl;
-		clog << "| Input [" << inputCounter++ << "/" << inputCount << "]: " << endl;
+		std::clog << "+" << std::endl;
+		std::clog << "| Input [" << inputCounter++ << "/" << inputCount << "]: " << std::endl;
 
 		for ( const auto & mpsmPair : substitutionMap )
-			clog << "| \t$" << mpsmPair.first << " -> " << mpiData.getMPIDHandle ( mpsmPair.second ).alias << endl;
+			std::clog << "| \t$" << mpsmPair.first << " -> " << mpiData.getMPIDHandle ( mpsmPair.second ).alias << std::endl;
 
-		clog << "| Pipelines:" << endl;
+		std::clog << "| Pipelines:" << std::endl;
 
 		int pipelineCounter = 1;
 		int pipelineCount = mpiData.getSubstitutionPipelines ( ).size ( );
 
 		for ( const MPPipeline & pipeline : mpiData.getSubstitutionPipelines ( ) ) {
 			if ( pipelineCounter != 1 )
-				clog << "|" << endl;
+				std::clog << "|" << std::endl;
 
-			string logFullPipeline;
+			std::string logFullPipeline;
 
 			for ( MPPipeline::const_iterator mppcIter = pipeline.cbegin ( ); mppcIter != pipeline.cend ( ); ++mppcIter ) {
 				if ( mppcIter != pipeline.cbegin ( ) )
@@ -62,11 +60,11 @@ MeasurementProvisionerResults MeasurementProvisioner::runConfiguration ( const M
 				logFullPipeline += mppcIter->getAlias ( );
 			}
 
-			clog << "| \t[" << pipelineCounter++ << "/" << pipelineCount << "]: " << logFullPipeline << endl;
+			std::clog << "| \t[" << pipelineCounter++ << "/" << pipelineCount << "]: " << logFullPipeline << std::endl;
 			mprir.pipelineResults.push_back ( runPipeline ( pipeline, substitutionMap, cfg ) );
 		}
 
-		clog << "+" << endl;
+		std::clog << "+" << std::endl;
 
 		mpr.inputResults.push_back ( std::move ( mprir ) );
 	}
@@ -76,11 +74,11 @@ MeasurementProvisionerResults MeasurementProvisioner::runConfiguration ( const M
 
 void MeasurementProvisioner::prepareEnvironment ( const MeasurementProvisionerConfiguration & cfg ) {
 
-	const string & workingDirectory = cfg.environment.workingDirectory;
+	const std::string & workingDirectory = cfg.environment.workingDirectory;
 
 	if ( workingDirectory.size ( ) == 0 ) return;
 
-	list < string > workingDirectoryExpansion = MPUtils::shellExpand ( workingDirectory );
+	std::list < std::string > workingDirectoryExpansion = MPUtils::shellExpand ( workingDirectory );
 
 	if ( workingDirectoryExpansion.size ( ) != 1 )
 		throw::exception::CommonException ( "MeasurementProvisioner: binaries directory: \"" + workingDirectory + "\" expansion failed" );
@@ -94,9 +92,9 @@ MPRPipelineResult MeasurementProvisioner::runPipeline ( const MPPipeline & pipel
 	 // setup environment for pipeline running
 	PipelineRunnerEnvironment pre;
 
-	ofdstream ofdlog ( pre.stderrFd );
+	std::ofdstream ofdlog ( pre.stderrFd );
 
-	vector < vector < MeasurementResults > > commandMeasurementSubResults;
+	std::vector < std::vector < MeasurementResults > > commandMeasurementSubResults;
 
 	MPRPipelineResult pipelineFinalResults = MPRPipelineResult ( );
 
@@ -105,9 +103,9 @@ MPRPipelineResult MeasurementProvisioner::runPipeline ( const MPPipeline & pipel
 	 // we repeat the pipeline measurement several times, then aggregate the results
 	for ( int iteration = 0; iteration < cfg.environment.pipelineIterations; ++iteration ) {
 
-		ofdlog << "| \titeration: \t" << iteration + 1 << flush;
+		ofdlog << "| \titeration: \t" << iteration + 1 << std::flush;
 
-		vector < MeasurementResults > pipelineMeasurementResults;
+		std::vector < MeasurementResults > pipelineMeasurementResults;
 
 		 // run one full pipeline
 		pre.commandFdInit ( );
@@ -116,7 +114,7 @@ MPRPipelineResult MeasurementProvisioner::runPipeline ( const MPPipeline & pipel
 			if ( mppcIter != pipeline.cbegin ( ) )
 				pre.commandFdSwap ( );
 
-			string commandToRun = mppcIter->substitute ( substitutionMap );
+			std::string commandToRun = mppcIter->substitute ( substitutionMap );
 
 			 // execute by the system shell!
 			int status = system ( commandToRun.c_str ( ) );
@@ -138,10 +136,10 @@ MPRPipelineResult MeasurementProvisioner::runPipeline ( const MPPipeline & pipel
 
 		 // if there was an error, we halt the execution of all iterations and report the error
 		if ( pipelineFinalResults.pipelineStatus.exitCode != 0 ) {
-			ofdlog << "\tERROR" << endl;
+			ofdlog << "\tERROR" << std::endl;
 			break;
 		}
-		ofdlog << "\tOK" << endl;
+		ofdlog << "\tOK" << std::endl;
 
 		commandMeasurementSubResults.push_back ( std::move ( pipelineMeasurementResults ) );
 	}
@@ -150,13 +148,13 @@ MPRPipelineResult MeasurementProvisioner::runPipeline ( const MPPipeline & pipel
 
 	 // if everything went smoothly, we aggregate the results
 	if ( pipelineFinalResults.pipelineStatus.exitCode == 0 ) {
-		vector < vector < MeasurementResults > > transposedCommandMeasurementSubResults ( commandMeasurementSubResults.size ( ) );
+		std::vector < std::vector < MeasurementResults > > transposedCommandMeasurementSubResults ( commandMeasurementSubResults.size ( ) );
 
-		for ( vector < MeasurementResults > & commandResults : commandMeasurementSubResults )
+		for ( std::vector < MeasurementResults > & commandResults : commandMeasurementSubResults )
 			for ( size_t i = 0; i < commandResults.size ( ); ++i )
 				transposedCommandMeasurementSubResults[i].push_back ( std::move ( commandResults[i] ) );
 
-		vector < vector < MeasurementResults > >::iterator tcmsIter = transposedCommandMeasurementSubResults.begin ( );
+		std::vector < std::vector < MeasurementResults > >::iterator tcmsIter = transposedCommandMeasurementSubResults.begin ( );
 		MPPipeline::const_iterator mppcIter = pipeline.cbegin ( );
 
 		for ( ; mppcIter != pipeline.cend ( ); ++mppcIter ) {
@@ -166,9 +164,9 @@ MPRPipelineResult MeasurementProvisioner::runPipeline ( const MPPipeline & pipel
 			}
 		}
 
-		ofdlog << "| \tpipeline: \tOK" << endl;
+		ofdlog << "| \tpipeline: \tOK" << std::endl;
 	} else {
-		ofdlog << "| \tpipeline: \tERROR" << endl;
+		ofdlog << "| \tpipeline: \tERROR" << std::endl;
 	}
 
 	return pipelineFinalResults;
@@ -209,7 +207,7 @@ MeasurementProvisioner::PipelineRunnerEnvironment::PipelineRunnerEnvironment ( )
 	close ( 2 );
 }
 
-MeasurementProvisioner::PipelineRunnerEnvironment::~PipelineRunnerEnvironment ( ) {
+MeasurementProvisioner::PipelineRunnerEnvironment::~PipelineRunnerEnvironment ( ) noexcept(false) {
 	 // close tmp files, which results in their deletion
 	MPUtils::closeShmFile ( measurementsTmpfile );
 	MPUtils::closeShmFile ( inputTmpfile );
@@ -277,13 +275,13 @@ void MeasurementProvisioner::PipelineRunnerEnvironment::commandFdEnd ( ) {
 		throw::exception::CommonException ( "MeasurementProvisioner: ftruncate failed" );
 }
 
-string MeasurementProvisioner::PipelineRunnerEnvironment::retrievePipelineError ( ) {
+std::string MeasurementProvisioner::PipelineRunnerEnvironment::retrievePipelineError ( ) {
 	 // rewind stderr to read the error message
 	lseek ( 2, 0, SEEK_SET );
-	ifdstream errfds ( 2 );
+	std::ifdstream errfds ( 2 );
 
 	 // read the whole stderr
-	stringstream buffer;
+	std::stringstream buffer;
 	buffer << errfds.rdbuf ( );
 
 	 // destroy stderr contents
@@ -299,9 +297,9 @@ MeasurementResults MeasurementProvisioner::PipelineRunnerEnvironment::retrieveMe
 	 // since we are at the end of file after the measurements, we need to rewind
 	lseek ( measurementsFd, 0, SEEK_SET );
 
-	ifdstream ifd ( measurementsFd );
+	std::ifdstream ifd ( measurementsFd );
 
-	deque < sax::Token > tokens;
+	std::deque < sax::Token > tokens;
 	sax::SaxParseInterface::parseStream ( ifd, tokens );
 
 	 // destroy the contents and rewind for another commands measurements
diff --git a/alib2measurepp/src/provisioner/MeasurementProvisioner.hpp b/alib2measurepp/src/provisioner/MeasurementProvisioner.hpp
index 6d4e83bfd4a89e9d89b808aa05c371d5b2b69118..cb0a50b64ca9cee85ac49a9bd4b15947c2dcb7e8 100644
--- a/alib2measurepp/src/provisioner/MeasurementProvisioner.hpp
+++ b/alib2measurepp/src/provisioner/MeasurementProvisioner.hpp
@@ -28,7 +28,7 @@ class MeasurementProvisioner {
 
 	public:
 		PipelineRunnerEnvironment ( );
-		~PipelineRunnerEnvironment ( );
+		~PipelineRunnerEnvironment ( ) noexcept(false);
 
 		void commandFdInit ( );
 		void commandFdSwap ( );
diff --git a/alib2measurepp/src/provisioner/MeasurementProvisionerConfigurationXml.cpp b/alib2measurepp/src/provisioner/MeasurementProvisionerConfigurationXml.cpp
index 8dd15b571f94763caf16be1445c677c181c600e8..044d3531a0e9fb3065409c07a4ee04b8b86f630b 100644
--- a/alib2measurepp/src/provisioner/MeasurementProvisionerConfigurationXml.cpp
+++ b/alib2measurepp/src/provisioner/MeasurementProvisionerConfigurationXml.cpp
@@ -6,32 +6,29 @@
 #include "MeasurementProvisionerConfigurationXml.hpp"
 #include "exception/CommonException.h"
 
-using namespace std;
-using namespace sax;
-
 namespace measurements {
 
-MeasurementProvisionerConfiguration MeasurementProvisionerConfigurationXml::parse ( deque < Token > & tokens ) {
+MeasurementProvisionerConfiguration MeasurementProvisionerConfigurationXml::parse ( std::deque < sax::Token > & tokens ) {
 	MeasurementProvisionerConfiguration configuration;
 
-	deque < Token >::iterator iter = tokens.begin ( );
+	std::deque < sax::Token >::iterator iter = tokens.begin ( );
 
 	if ( iter == tokens.end ( ) ) throw::exception::CommonException ( "Empty tokens list" );
 
 	parseMeasurementProvisioner ( configuration, iter );
 
-	if ( iter != tokens.end ( ) ) throw::exception::CommonException ( "Unexpeted tokens at the end of the xml" );
+	if ( iter != tokens.end ( ) ) throw::exception::CommonException ( "Unexpected tokens at the end of the XML" );
 
 	return configuration;
 }
 
 void MeasurementProvisionerConfigurationXml::parseMeasurementProvisioner ( MeasurementProvisionerConfiguration & mpc, std::deque < sax::Token >::iterator & iter ) {
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, MEASUREMENT_PROVISIONER_TAG );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, MEASUREMENT_PROVISIONER_TAG );
 
 	for ( ; ; ) {
-		if ( !FromXMLParserHelper::isTokenType ( iter, Token::TokenType::START_ELEMENT ) ) break;
+		if ( !sax::FromXMLParserHelper::isTokenType ( iter, sax::Token::TokenType::START_ELEMENT ) ) break;
 
-		string data = FromXMLParserHelper::getTokenData ( iter, Token::TokenType::START_ELEMENT );
+		std::string data = sax::FromXMLParserHelper::getTokenData ( iter, sax::Token::TokenType::START_ELEMENT );
 
 		if ( data == ENVIRONMENT_TAG )
 			parseEnvironment ( mpc, iter );
@@ -43,43 +40,43 @@ void MeasurementProvisionerConfigurationXml::parseMeasurementProvisioner ( Measu
 			break;
 	}
 
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, MEASUREMENT_PROVISIONER_TAG );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, MEASUREMENT_PROVISIONER_TAG );
 }
 
 void MeasurementProvisionerConfigurationXml::parseEnvironment ( MeasurementProvisionerConfiguration & mpc, std::deque < sax::Token >::iterator & iter ) {
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, ENVIRONMENT_TAG );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, ENVIRONMENT_TAG );
 
 	mpc.environment.workingDirectory = "";
 	mpc.environment.pipelineIterations = 1;
 
 	for ( ; ; ) {
-		if ( !FromXMLParserHelper::isTokenType ( iter, Token::TokenType::START_ELEMENT ) ) break;
+		if ( !sax::FromXMLParserHelper::isTokenType ( iter, sax::Token::TokenType::START_ELEMENT ) ) break;
 
-		string data = FromXMLParserHelper::getTokenData ( iter, Token::TokenType::START_ELEMENT );
+		std::string data = sax::FromXMLParserHelper::getTokenData ( iter, sax::Token::TokenType::START_ELEMENT );
 
 		if ( data == WORKING_DIRECTORY_TAG ) {
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, WORKING_DIRECTORY_TAG );
-			mpc.environment.workingDirectory = FromXMLParserHelper::popTokenData ( iter, Token::TokenType::CHARACTER );
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, WORKING_DIRECTORY_TAG );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, WORKING_DIRECTORY_TAG );
+			mpc.environment.workingDirectory = sax::FromXMLParserHelper::popTokenData ( iter, sax::Token::TokenType::CHARACTER );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, WORKING_DIRECTORY_TAG );
 		} else if ( data == PIPELINE_ITERATIONS_TAG ) {
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, PIPELINE_ITERATIONS_TAG );
-			mpc.environment.pipelineIterations = std::stoi ( FromXMLParserHelper::popTokenData ( iter, Token::TokenType::CHARACTER ) );
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, PIPELINE_ITERATIONS_TAG );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, PIPELINE_ITERATIONS_TAG );
+			mpc.environment.pipelineIterations = std::stoi ( sax::FromXMLParserHelper::popTokenData ( iter, sax::Token::TokenType::CHARACTER ) );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, PIPELINE_ITERATIONS_TAG );
 		} else {
 			break;
 		}
 	}
 
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, ENVIRONMENT_TAG );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, ENVIRONMENT_TAG );
 }
 
 void MeasurementProvisionerConfigurationXml::parseInputData ( MeasurementProvisionerConfiguration & mpc, std::deque < sax::Token >::iterator & iter ) {
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, INPUT_DATA_TAG );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, INPUT_DATA_TAG );
 
 	for ( ; ; ) {
-		if ( !FromXMLParserHelper::isTokenType ( iter, Token::TokenType::START_ELEMENT ) ) break;
+		if ( !sax::FromXMLParserHelper::isTokenType ( iter, sax::Token::TokenType::START_ELEMENT ) ) break;
 
-		string data = FromXMLParserHelper::getTokenData ( iter, Token::TokenType::START_ELEMENT );
+		std::string data = sax::FromXMLParserHelper::getTokenData ( iter, sax::Token::TokenType::START_ELEMENT );
 
 		if ( data == INPUT_DATA_BATCH_TAG )
 			parseInputBatch ( mpc, iter );
@@ -87,22 +84,22 @@ void MeasurementProvisionerConfigurationXml::parseInputData ( MeasurementProvisi
 			break;
 	}
 
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, INPUT_DATA_TAG );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, INPUT_DATA_TAG );
 }
 
 void MeasurementProvisionerConfigurationXml::parseInputBatch ( MeasurementProvisionerConfiguration & mpc, std::deque < sax::Token >::iterator & iter ) {
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, INPUT_DATA_BATCH_TAG );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, INPUT_DATA_BATCH_TAG );
 
 	MPCInputBatch mpcib;
 
 	mpcib.forcedDependencyBatch = false;
 
-	if ( FromXMLParserHelper::isTokenType ( iter, Token::TokenType::START_ATTRIBUTE ) ) {
-		string attrName = FromXMLParserHelper::getTokenData ( iter, Token::TokenType::START_ATTRIBUTE );
+	if ( sax::FromXMLParserHelper::isTokenType ( iter, sax::Token::TokenType::START_ATTRIBUTE ) ) {
+		std::string attrName = sax::FromXMLParserHelper::getTokenData ( iter, sax::Token::TokenType::START_ATTRIBUTE );
 
 		if ( attrName == INPUT_DATA_BATCH_ATTR_DEPENDENCY_NAME ) {
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ATTRIBUTE, attrName );
-			string attrVal = FromXMLParserHelper::popTokenData ( iter, Token::TokenType::CHARACTER );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ATTRIBUTE, attrName );
+			std::string attrVal = sax::FromXMLParserHelper::popTokenData ( iter, sax::Token::TokenType::CHARACTER );
 
 			if ( attrVal == "true" )
 				mpcib.forcedDependencyBatch = true;
@@ -111,21 +108,21 @@ void MeasurementProvisionerConfigurationXml::parseInputBatch ( MeasurementProvis
 			else
 				throw::exception::CommonException ( "XML: MPCInputBatch malformed boolean attr: " + attrName );
 
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ATTRIBUTE, attrName );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ATTRIBUTE, attrName );
 		}
 	}
 
 	for ( ; ; ) {
-		if ( !FromXMLParserHelper::isTokenType ( iter, Token::TokenType::START_ELEMENT ) ) break;
+		if ( !sax::FromXMLParserHelper::isTokenType ( iter, sax::Token::TokenType::START_ELEMENT ) ) break;
 
-		string data = FromXMLParserHelper::getTokenData ( iter, Token::TokenType::START_ELEMENT );
+		std::string data = sax::FromXMLParserHelper::getTokenData ( iter, sax::Token::TokenType::START_ELEMENT );
 
 		mpcib.batch.push_back ( parseInputDatum ( data, iter ) );
 	}
 
 	mpc.inputBatches.push_back ( std::move ( mpcib ) );
 
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, INPUT_DATA_BATCH_TAG );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, INPUT_DATA_BATCH_TAG );
 }
 
 MPCInputDatum MeasurementProvisionerConfigurationXml::parseInputDatum ( const std::string & tag, std::deque < sax::Token >::iterator & iter ) {
@@ -142,17 +139,17 @@ MPCInputDatum MeasurementProvisionerConfigurationXml::parseInputDatum ( const st
 	else
 		throw::exception::CommonException ( "XML: Unknown MPCInputDatum type" );
 
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, tag );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, tag );
 
 	bool foundId = false;
 
 	for ( ; ; ) {
-		if ( !FromXMLParserHelper::isTokenType ( iter, Token::TokenType::START_ATTRIBUTE ) ) break;
+		if ( !sax::FromXMLParserHelper::isTokenType ( iter, sax::Token::TokenType::START_ATTRIBUTE ) ) break;
 
-		string attrName = FromXMLParserHelper::getTokenData ( iter, Token::TokenType::START_ATTRIBUTE );
-		FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ATTRIBUTE, attrName );
-		string attrVal = FromXMLParserHelper::popTokenData ( iter, Token::TokenType::CHARACTER );
-		FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ATTRIBUTE, attrName );
+		std::string attrName = sax::FromXMLParserHelper::getTokenData ( iter, sax::Token::TokenType::START_ATTRIBUTE );
+		sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ATTRIBUTE, attrName );
+		std::string attrVal = sax::FromXMLParserHelper::popTokenData ( iter, sax::Token::TokenType::CHARACTER );
+		sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ATTRIBUTE, attrName );
 
 		if ( attrName == INPUT_DATA_ATTR_ID_NAME ) {
 			mpcid.id = std::stoi ( attrVal );
@@ -169,19 +166,19 @@ MPCInputDatum MeasurementProvisionerConfigurationXml::parseInputDatum ( const st
 	if ( !foundId )
 		throw::exception::CommonException ( "XML: MPCInputDatum id attr was not specified" );
 
-	mpcid.value = FromXMLParserHelper::popTokenData ( iter, Token::TokenType::CHARACTER );
+	mpcid.value = sax::FromXMLParserHelper::popTokenData ( iter, sax::Token::TokenType::CHARACTER );
 
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, tag );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, tag );
 	return mpcid;
 }
 
 void MeasurementProvisionerConfigurationXml::parsePipelines ( MeasurementProvisionerConfiguration & mpc, std::deque < sax::Token >::iterator & iter ) {
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, PIPELINES_TAG );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, PIPELINES_TAG );
 
 	for ( ; ; ) {
-		if ( !FromXMLParserHelper::isTokenType ( iter, Token::TokenType::START_ELEMENT ) ) break;
+		if ( !sax::FromXMLParserHelper::isTokenType ( iter, sax::Token::TokenType::START_ELEMENT ) ) break;
 
-		string data = FromXMLParserHelper::getTokenData ( iter, Token::TokenType::START_ELEMENT );
+		std::string data = sax::FromXMLParserHelper::getTokenData ( iter, sax::Token::TokenType::START_ELEMENT );
 
 		if ( data == PIPELINE_TAG ) {
 			mpc.pipelines.push_back ( { } );
@@ -191,16 +188,16 @@ void MeasurementProvisionerConfigurationXml::parsePipelines ( MeasurementProvisi
 		}
 	}
 
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, PIPELINES_TAG );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, PIPELINES_TAG );
 }
 
 void MeasurementProvisionerConfigurationXml::parsePipeline ( MPCPipeline & pipeline, std::deque < sax::Token >::iterator & iter ) {
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, PIPELINE_TAG );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, PIPELINE_TAG );
 
 	for ( ; ; ) {
-		if ( !FromXMLParserHelper::isTokenType ( iter, Token::TokenType::START_ELEMENT ) ) break;
+		if ( !sax::FromXMLParserHelper::isTokenType ( iter, sax::Token::TokenType::START_ELEMENT ) ) break;
 
-		string data = FromXMLParserHelper::getTokenData ( iter, Token::TokenType::START_ELEMENT );
+		std::string data = sax::FromXMLParserHelper::getTokenData ( iter, sax::Token::TokenType::START_ELEMENT );
 
 		if ( data == COMMAND_TAG )
 			pipeline.push_back ( parsePipelineCommand ( iter ) );
@@ -208,23 +205,23 @@ void MeasurementProvisionerConfigurationXml::parsePipeline ( MPCPipeline & pipel
 			break;
 	}
 
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, PIPELINE_TAG );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, PIPELINE_TAG );
 }
 
 MPCPipelineCommand MeasurementProvisionerConfigurationXml::parsePipelineCommand ( std::deque < sax::Token >::iterator & iter ) {
 
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, COMMAND_TAG );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, COMMAND_TAG );
 
 	MPCPipelineCommand mpcpc;
 
 	mpcpc.measure = true;
 	mpcpc.alias = "";
 
-	if ( FromXMLParserHelper::isTokenType ( iter, Token::TokenType::START_ATTRIBUTE ) ) {
-		string attrName = FromXMLParserHelper::getTokenData ( iter, Token::TokenType::START_ATTRIBUTE );
-		FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ATTRIBUTE, attrName );
-		string attrVal = FromXMLParserHelper::popTokenData ( iter, Token::TokenType::CHARACTER );
-		FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ATTRIBUTE, attrName );
+	if ( sax::FromXMLParserHelper::isTokenType ( iter, sax::Token::TokenType::START_ATTRIBUTE ) ) {
+		std::string attrName = sax::FromXMLParserHelper::getTokenData ( iter, sax::Token::TokenType::START_ATTRIBUTE );
+		sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ATTRIBUTE, attrName );
+		std::string attrVal = sax::FromXMLParserHelper::popTokenData ( iter, sax::Token::TokenType::CHARACTER );
+		sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ATTRIBUTE, attrName );
 
 		if ( attrName == COMMAND_ATTR_MEASURE_NAME ) {
 			if ( attrVal == "true" )
@@ -240,33 +237,33 @@ MPCPipelineCommand MeasurementProvisionerConfigurationXml::parsePipelineCommand
 		}
 	}
 
-	mpcpc.command = FromXMLParserHelper::popTokenData ( iter, Token::TokenType::CHARACTER );
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, COMMAND_TAG );
+	mpcpc.command = sax::FromXMLParserHelper::popTokenData ( iter, sax::Token::TokenType::CHARACTER );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, COMMAND_TAG );
 
 	return mpcpc;
 }
 
-string MeasurementProvisionerConfigurationXml::MEASUREMENT_PROVISIONER_TAG = "MeasurementProvisioner";
+std::string MeasurementProvisionerConfigurationXml::MEASUREMENT_PROVISIONER_TAG = "MeasurementProvisioner";
 
-string MeasurementProvisionerConfigurationXml::ENVIRONMENT_TAG = "Environment";
-string MeasurementProvisionerConfigurationXml::WORKING_DIRECTORY_TAG = "WorkingDirectory";
-string MeasurementProvisionerConfigurationXml::PIPELINE_ITERATIONS_TAG = "PipelineIterations";
+std::string MeasurementProvisionerConfigurationXml::ENVIRONMENT_TAG = "Environment";
+std::string MeasurementProvisionerConfigurationXml::WORKING_DIRECTORY_TAG = "WorkingDirectory";
+std::string MeasurementProvisionerConfigurationXml::PIPELINE_ITERATIONS_TAG = "PipelineIterations";
 
-string MeasurementProvisionerConfigurationXml::INPUT_DATA_TAG = "InputData";
-string MeasurementProvisionerConfigurationXml::INPUT_DATA_BATCH_TAG = "InputBatch";
-string MeasurementProvisionerConfigurationXml::INPUT_DATA_BATCH_ATTR_DEPENDENCY_NAME = "dependency";
+std::string MeasurementProvisionerConfigurationXml::INPUT_DATA_TAG = "InputData";
+std::string MeasurementProvisionerConfigurationXml::INPUT_DATA_BATCH_TAG = "InputBatch";
+std::string MeasurementProvisionerConfigurationXml::INPUT_DATA_BATCH_ATTR_DEPENDENCY_NAME = "dependency";
 
-string MeasurementProvisionerConfigurationXml::INPUT_DATA_FILE_TAG = "File";
-string MeasurementProvisionerConfigurationXml::INPUT_DATA_GENERATOR_TAG = "Generator";
+std::string MeasurementProvisionerConfigurationXml::INPUT_DATA_FILE_TAG = "File";
+std::string MeasurementProvisionerConfigurationXml::INPUT_DATA_GENERATOR_TAG = "Generator";
 
-string MeasurementProvisionerConfigurationXml::INPUT_DATA_ATTR_ID_NAME = "id";
-string MeasurementProvisionerConfigurationXml::INPUT_DATA_ATTR_COUNT_NAME = "count";
-string MeasurementProvisionerConfigurationXml::INPUT_DATA_ATTR_ALIAS_NAME = "alias";
+std::string MeasurementProvisionerConfigurationXml::INPUT_DATA_ATTR_ID_NAME = "id";
+std::string MeasurementProvisionerConfigurationXml::INPUT_DATA_ATTR_COUNT_NAME = "count";
+std::string MeasurementProvisionerConfigurationXml::INPUT_DATA_ATTR_ALIAS_NAME = "alias";
 
-string MeasurementProvisionerConfigurationXml::PIPELINES_TAG = "Pipelines";
-string MeasurementProvisionerConfigurationXml::PIPELINE_TAG	 = "Pipeline";
-string MeasurementProvisionerConfigurationXml::COMMAND_TAG = "Command";
+std::string MeasurementProvisionerConfigurationXml::PIPELINES_TAG = "Pipelines";
+std::string MeasurementProvisionerConfigurationXml::PIPELINE_TAG	 = "Pipeline";
+std::string MeasurementProvisionerConfigurationXml::COMMAND_TAG = "Command";
 
-string MeasurementProvisionerConfigurationXml::COMMAND_ATTR_MEASURE_NAME = "measure";
-string MeasurementProvisionerConfigurationXml::COMMAND_ATTR_ALIAS_NAME = "alias";
+std::string MeasurementProvisionerConfigurationXml::COMMAND_ATTR_MEASURE_NAME = "measure";
+std::string MeasurementProvisionerConfigurationXml::COMMAND_ATTR_ALIAS_NAME = "alias";
 }
diff --git a/alib2measurepp/src/provisioner/MeasurementProvisionerInputData.cpp b/alib2measurepp/src/provisioner/MeasurementProvisionerInputData.cpp
index 5882a209fcf96fc86512436c6ad2d98034abe497..9b890995fbe5a45b6220cf48f15256e9dac212a1 100644
--- a/alib2measurepp/src/provisioner/MeasurementProvisionerInputData.cpp
+++ b/alib2measurepp/src/provisioner/MeasurementProvisionerInputData.cpp
@@ -8,8 +8,6 @@
 #include "MeasurementProvisionerUtils.hpp"
 #include "exception/CommonException.h"
 
-using namespace std;
-
 namespace measurements {
 
 MPInputDatum::MPInputDatum ( MPInputDatum::Type type, std::string filename, std::string alias ) : type ( type ), filename ( std::move ( filename ) ), alias ( std::move ( alias ) ) {
@@ -22,13 +20,13 @@ MPInputDatum::~MPInputDatum ( ) {
 
 /*---------------------------------------------------------------------------------------------------------------*/
 
-MPSubstitution::MPSubstitution ( const string & str ) {
+MPSubstitution::MPSubstitution ( const std::string & str ) {
 	size_t prevPos = 0;
 
 	for ( ; ; ) {
 		size_t pos = findNextSubstitution ( str, prevPos );
 
-		if ( pos != string::npos ) {
+		if ( pos != std::string::npos ) {
 
 			tokens.emplace_back ( str.substr ( prevPos, pos - prevPos ) );
 			tokens.emplace_back ( "" );
@@ -41,7 +39,7 @@ MPSubstitution::MPSubstitution ( const string & str ) {
 		} else {
 			 // is there a remaining token?
 			if ( prevPos != str.size ( ) )
-				tokens.emplace_back ( str.substr ( prevPos, string::npos ) );
+				tokens.emplace_back ( str.substr ( prevPos, std::string::npos ) );
 
 			break;
 		}
@@ -52,11 +50,11 @@ MPSubstitution::MPSubstitution ( const string & str ) {
 	substitutionPattern.insert ( substitutionIdxs.begin ( ), substitutionIdxs.end ( ) );
 }
 
-string MPSubstitution::substitute ( const MPSubstitutionMap & substitutionMap ) const {
-	string res;
+std::string MPSubstitution::substitute ( const MPSubstitutionMap & substitutionMap ) const {
+	std::string res;
 	int curSubstitutionIdx = 0;
 
-	for ( const string & token : tokens ) {
+	for ( const std::string & token : tokens ) {
 		if ( token.size ( ) ) {
 			res += token;
 		} else {
@@ -70,26 +68,26 @@ string MPSubstitution::substitute ( const MPSubstitutionMap & substitutionMap )
 	return res;
 }
 
-const set < int > & MPSubstitution::getSubstitutionPattern ( ) const {
+const std::set < int > & MPSubstitution::getSubstitutionPattern ( ) const {
 	return substitutionPattern;
 }
 
 size_t MPSubstitution::findNextSubstitution ( const std::string & str, size_t prevPos ) {
 	size_t pos = str.find_first_of ( SUBSTITUTION_DELIM, prevPos );
 
-	if ( ( pos != string::npos ) && ( pos + 1 < str.size ( ) ) && isdigit ( str[pos + 1] ) )
+	if ( ( pos != std::string::npos ) && ( pos + 1 < str.size ( ) ) && isdigit ( str[pos + 1] ) )
 		return pos;
 
-	return string::npos;
+	return std::string::npos;
 }
 
-set < int > MPSubstitution::requiredSubstitutionPattern ( const string & str ) {
-	set < int > pattern;
+std::set < int > MPSubstitution::requiredSubstitutionPattern ( const std::string & str ) {
+	std::set < int > pattern;
 
 	size_t prevPos = 0;
 	size_t pos;
 
-	while ( ( pos = findNextSubstitution ( str, prevPos ) ) != string::npos ) {
+	while ( ( pos = findNextSubstitution ( str, prevPos ) ) != std::string::npos ) {
 		pattern.insert ( str[pos + 1] - '0' );
 		prevPos = pos + 2;
 	}
@@ -97,8 +95,8 @@ set < int > MPSubstitution::requiredSubstitutionPattern ( const string & str ) {
 	return pattern;
 }
 
-bool MPSubstitution::containsSubstitution ( const string & str ) {
-	return findNextSubstitution ( str, 0 ) != string::npos;
+bool MPSubstitution::containsSubstitution ( const std::string & str ) {
+	return findNextSubstitution ( str, 0 ) != std::string::npos;
 }
 
 /*---------------------------------------------------------------------------------------------------------------*/
@@ -106,8 +104,8 @@ bool MPSubstitution::containsSubstitution ( const string & str ) {
 MPPipelineCommand::MPPipelineCommand ( std::string str, std::string alias, bool measure ) : MPSubstitution ( str ), rawCommand ( std::move ( str ) ), alias ( std::move ( alias ) ), measure ( measure ) {
 }
 
-string MPPipelineCommand::substitute ( const MPSubstitutionMap & substitutionMap ) const {
-	string res = MPSubstitution::substitute ( substitutionMap );
+std::string MPPipelineCommand::substitute ( const MPSubstitutionMap & substitutionMap ) const {
+	std::string res = MPSubstitution::substitute ( substitutionMap );
 
 	if ( measure )
 		res += " -m";
@@ -115,11 +113,11 @@ string MPPipelineCommand::substitute ( const MPSubstitutionMap & substitutionMap
 	return res;
 }
 
-const string & MPPipelineCommand::getRawCommand ( ) const {
+const std::string & MPPipelineCommand::getRawCommand ( ) const {
 	return rawCommand;
 }
 
-const string & MPPipelineCommand::getAlias ( ) const {
+const std::string & MPPipelineCommand::getAlias ( ) const {
 	return alias;
 }
 
@@ -133,18 +131,18 @@ MPInputData::MPInputData ( const MeasurementProvisionerConfiguration & mpc ) {
 	processMPCInputData ( mpc );
 }
 
-const MPInputDatum & MPInputData::getMPIDHandle ( const string & filename ) const {
+const MPInputDatum & MPInputData::getMPIDHandle ( const std::string & filename ) const {
 	if ( this->mpidHandles.find ( filename ) == this->mpidHandles.end ( ) )
 		throw::exception::CommonException ( "MPInputData: trying to retrieve nonexistent handle: " + filename );
 
 	return this->mpidHandles.find ( filename )->second;
 }
 
-const list < MPSubstitutionMap > & MPInputData::getSubstitutionMaps ( ) const {
+const std::list < MPSubstitutionMap > & MPInputData::getSubstitutionMaps ( ) const {
 	return this->substitutionMaps;
 }
 
-const list < MPPipeline > & MPInputData::getSubstitutionPipelines ( ) const {
+const std::list < MPPipeline > & MPInputData::getSubstitutionPipelines ( ) const {
 	return this->substitutionPipelines;
 }
 
@@ -170,7 +168,7 @@ void MPInputData::processMPCInputData ( const MeasurementProvisionerConfiguratio
 
 		 // generate substitution pattern in the batch, determine whether it is simple or dependency batch
 		bool isSimpleBatch = !inputBatch.forcedDependencyBatch;
-		set < int > inputSubstitutionPattern;
+		std::set < int > inputSubstitutionPattern;
 
 		for ( const MPCInputDatum & inputDatum : inputBatch.batch ) {
 			if ( MPSubstitution::containsSubstitution ( inputDatum.value ) )
@@ -198,30 +196,30 @@ void MPInputData::insertMPInputDatum ( MPInputDatum::Type type, std::string file
 	this->mpidHandles.emplace ( mpid.filename, std::move ( mpid ) );
 }
 
-void MPInputData::processSimpleBatchFileData ( const MPCInputDatum & inputDatum, list < string > & mpidList ) {
-	list < string > expandedFilename = MPUtils::shellExpand ( inputDatum.value );
+void MPInputData::processSimpleBatchFileData ( const MPCInputDatum & inputDatum, std::list < std::string > & mpidList ) {
+	std::list < std::string > expandedFilename = MPUtils::shellExpand ( inputDatum.value );
 
 	for ( int i = 0; i < inputDatum.count; ++i )
-		for ( const string & file : expandedFilename ) {
+		for ( const std::string & file : expandedFilename ) {
 			insertMPInputDatum ( MPInputDatum::Type::FILE, file, constructFileInputDatumAlias ( file, inputDatum ) );
 			mpidList.push_back ( file );
 		}
 
 }
 
-void MPInputData::processSimpleBatchGeneratorData ( const MPCInputDatum & inputDatum, list < string > & mpidList ) {
+void MPInputData::processSimpleBatchGeneratorData ( const MPCInputDatum & inputDatum, std::list < std::string > & mpidList ) {
 	for ( int i = 0; i < inputDatum.count; ++i ) {
-		string filename = MPUtils::generateTmpfileFromCommand ( inputDatum.value );
+		std::string filename = MPUtils::generateTmpfileFromCommand ( inputDatum.value );
 		insertMPInputDatum ( MPInputDatum::Type::GENERATOR, filename, constructGeneratorInputDatumAlias ( inputDatum ) );
 		mpidList.push_back ( std::move ( filename ) );
 	}
 }
 
 void MPInputData::processSimpleBatch ( const MPCInputBatch & inputBatch ) {
-	map < int, list < string > > distributedMPInputData;
+	std::map < int, std::list < std::string > > distributedMPInputData;
 
 	for ( const MPCInputDatum & inputDatum : inputBatch.batch ) {
-		list < string > & didList = distributedMPInputData[inputDatum.id];
+		std::list < std::string > & didList = distributedMPInputData[inputDatum.id];
 
 		switch ( inputDatum.type ) {
 		case MPCInputDatum::Type::FILE:
@@ -239,7 +237,7 @@ void MPInputData::processSimpleBatch ( const MPCInputBatch & inputBatch ) {
 
 	for ( const auto & didPair : distributedMPInputData )
 		if ( didLen != didPair.second.size ( ) )
-			throw::exception::CommonException ( "MPInputData: Not enough data for id " + to_string ( didPair.first ) + " in input batch to make substitution maps" );
+			throw::exception::CommonException ( "MPInputData: Not enough data for id " + std::to_string ( didPair.first ) + " in input batch to make substitution maps" );
 
 	for ( size_t i = 0; i < didLen; ++i ) {
 		MPSubstitutionMap substitutionMap;
@@ -254,9 +252,9 @@ void MPInputData::processSimpleBatch ( const MPCInputBatch & inputBatch ) {
 }
 
 void MPInputData::processDependencyBatchFileData ( const MPCInputDatum & inputDatum, const MPSubstitutionMap & prevSubstitutionMap, std::list < MPSubstitutionMap > & curSubstitutionMaps ) {
-	list < string > expandedFilename = MPUtils::shellExpand ( inputDatum.value );
+	std::list < std::string > expandedFilename = MPUtils::shellExpand ( inputDatum.value );
 
-	for ( string & file : expandedFilename ) {
+	for ( std::string & file : expandedFilename ) {
 		insertMPInputDatum ( MPInputDatum::Type::FILE, file, constructFileInputDatumAlias ( file, inputDatum ) );
 
 		for ( int i = 0; i < inputDatum.count; ++i ) {
@@ -273,7 +271,7 @@ void MPInputData::processDependencyBatchGeneratorData ( const MPCInputDatum & in
 		MPSubstitutionMap resultSubstitutionMap = prevSubstitutionMap;
 		MPSubstitution generatorSubstitution ( inputDatum.value );
 
-		string filename = MPUtils::generateTmpfileFromCommand ( generatorSubstitution.substitute ( prevSubstitutionMap ) );
+		std::string filename = MPUtils::generateTmpfileFromCommand ( generatorSubstitution.substitute ( prevSubstitutionMap ) );
 		insertMPInputDatum ( MPInputDatum::Type::GENERATOR, filename, constructGeneratorInputDatumAlias ( inputDatum ) );
 
 		resultSubstitutionMap[inputDatum.id] = filename;
@@ -288,19 +286,19 @@ void MPInputData::processDependencyBatch ( const MPCInputBatch & inputBatch ) {
 	// the already processed substitution maps into the batch being processed
 
 	 // distribute MPCInputData by their ids for processing in order
-	map < int, list < MPCInputDatum > > distributedMPCInputData;
+	std::map < int, std::list < MPCInputDatum > > distributedMPCInputData;
 
 	for ( const MPCInputDatum & inputDatum : inputBatch.batch )
 		distributedMPCInputData[inputDatum.id].push_back ( inputDatum );
 
-	list < MPSubstitutionMap > prevSubstitutionMaps;
+	std::list < MPSubstitutionMap > prevSubstitutionMaps;
 
 	for ( auto & didPair : distributedMPCInputData ) {
-		list < MPSubstitutionMap > curSubstitutionMaps;
+		std::list < MPSubstitutionMap > curSubstitutionMaps;
 
 		 // treat first id data like simple batch data, because we forbid them to have substitutions
 		if ( didPair.first == distributedMPCInputData.begin ( )->first ) {
-			list < string > filenameList;
+			std::list < std::string > filenameList;
 
 			for ( MPCInputDatum & inputDatum : didPair.second )
 				switch ( inputDatum.type ) {
diff --git a/alib2measurepp/src/provisioner/MeasurementProvisionerResultsXml.cpp b/alib2measurepp/src/provisioner/MeasurementProvisionerResultsXml.cpp
index f0bf9c114648a7ee0f40f1ab1b7ca7e7aa2f8a4c..1b6be258ae65e77fde1ab22456c30d778653d749 100644
--- a/alib2measurepp/src/provisioner/MeasurementProvisionerResultsXml.cpp
+++ b/alib2measurepp/src/provisioner/MeasurementProvisionerResultsXml.cpp
@@ -7,116 +7,113 @@
 #include "sax/FromXMLParserHelper.h"
 #include <measure>
 
-using namespace std;
-using namespace sax;
-
 namespace measurements {
 
-deque < Token > MeasurementProvisionerResultsXml::compose ( const MeasurementProvisionerResults & mpr ) {
-	deque < Token > tokens;
+std::deque < sax::Token > MeasurementProvisionerResultsXml::compose ( const MeasurementProvisionerResults & mpr ) {
+	std::deque < sax::Token > tokens;
 
-	tokens.emplace_back ( MEASUREMENT_PROVISIONER_RESULTS_TAG, Token::TokenType::START_ELEMENT );
+	tokens.emplace_back ( MEASUREMENT_PROVISIONER_RESULTS_TAG, sax::Token::TokenType::START_ELEMENT );
 
 	for ( const MPRInputResult & mprir : mpr.inputResults )
 		composeMeasurementProvisionerResult ( tokens, mprir );
 
-	tokens.emplace_back ( MEASUREMENT_PROVISIONER_RESULTS_TAG, Token::TokenType::END_ELEMENT );
+	tokens.emplace_back ( MEASUREMENT_PROVISIONER_RESULTS_TAG, sax::Token::TokenType::END_ELEMENT );
 	return tokens;
 }
 
-void MeasurementProvisionerResultsXml::composeMeasurementProvisionerResult ( deque < Token > & tokens, const MPRInputResult & mprir ) {
-	tokens.emplace_back ( MEASUREMENT_PROVISIONER_RESULT_TAG, Token::TokenType::START_ELEMENT );
+void MeasurementProvisionerResultsXml::composeMeasurementProvisionerResult ( std::deque < sax::Token > & tokens, const MPRInputResult & mprir ) {
+	tokens.emplace_back ( MEASUREMENT_PROVISIONER_RESULT_TAG, sax::Token::TokenType::START_ELEMENT );
 
 	composeInputs ( tokens, mprir );
 	composePipelines ( tokens, mprir );
 
-	tokens.emplace_back ( MEASUREMENT_PROVISIONER_RESULT_TAG, Token::TokenType::END_ELEMENT );
+	tokens.emplace_back ( MEASUREMENT_PROVISIONER_RESULT_TAG, sax::Token::TokenType::END_ELEMENT );
 }
 
-void MeasurementProvisionerResultsXml::composeInputs ( deque < Token > & tokens, const MPRInputResult & mprir ) {
-	tokens.emplace_back ( INPUTS_TAG, Token::TokenType::START_ELEMENT );
+void MeasurementProvisionerResultsXml::composeInputs ( std::deque < sax::Token > & tokens, const MPRInputResult & mprir ) {
+	tokens.emplace_back ( INPUTS_TAG, sax::Token::TokenType::START_ELEMENT );
 
 	for ( const std::pair < const int, std::string > & input : mprir.inputs ) {
-		tokens.emplace_back ( INPUT_TAG, Token::TokenType::START_ELEMENT );
-		tokens.emplace_back ( INPUT_ATTR_ID_NAME, Token::TokenType::START_ATTRIBUTE );
-		tokens.emplace_back ( std::to_string ( input.first ), Token::TokenType::CHARACTER );
-		tokens.emplace_back ( INPUT_ATTR_ID_NAME, Token::TokenType::END_ATTRIBUTE );
-		tokens.emplace_back ( input.second, Token::TokenType::CHARACTER );
-		tokens.emplace_back ( INPUT_TAG, Token::TokenType::END_ELEMENT );
+		tokens.emplace_back ( INPUT_TAG, sax::Token::TokenType::START_ELEMENT );
+		tokens.emplace_back ( INPUT_ATTR_ID_NAME, sax::Token::TokenType::START_ATTRIBUTE );
+		tokens.emplace_back ( std::to_string ( input.first ), sax::Token::TokenType::CHARACTER );
+		tokens.emplace_back ( INPUT_ATTR_ID_NAME, sax::Token::TokenType::END_ATTRIBUTE );
+		tokens.emplace_back ( input.second, sax::Token::TokenType::CHARACTER );
+		tokens.emplace_back ( INPUT_TAG, sax::Token::TokenType::END_ELEMENT );
 	}
 
-	tokens.emplace_back ( INPUTS_TAG, Token::TokenType::END_ELEMENT );
+	tokens.emplace_back ( INPUTS_TAG, sax::Token::TokenType::END_ELEMENT );
 }
 
-void MeasurementProvisionerResultsXml::composePipelines ( deque < Token > & tokens, const MPRInputResult & mprir ) {
-	tokens.emplace_back ( PIPELINES_TAG, Token::TokenType::START_ELEMENT );
+void MeasurementProvisionerResultsXml::composePipelines ( std::deque < sax::Token > & tokens, const MPRInputResult & mprir ) {
+	tokens.emplace_back ( PIPELINES_TAG, sax::Token::TokenType::START_ELEMENT );
 
 	for ( const MPRPipelineResult & mprpr : mprir.pipelineResults )
 		composePipeline ( tokens, mprpr );
 
-	tokens.emplace_back ( PIPELINES_TAG, Token::TokenType::END_ELEMENT );
+	tokens.emplace_back ( PIPELINES_TAG, sax::Token::TokenType::END_ELEMENT );
 }
 
-void MeasurementProvisionerResultsXml::composePipeline ( deque < Token > & tokens, const MPRPipelineResult & mprpr ) {
-	tokens.emplace_back ( PIPELINE_TAG, Token::TokenType::START_ELEMENT );
+void MeasurementProvisionerResultsXml::composePipeline ( std::deque < sax::Token > & tokens, const MPRPipelineResult & mprpr ) {
+	tokens.emplace_back ( PIPELINE_TAG, sax::Token::TokenType::START_ELEMENT );
 
 	composePipelineStatus ( tokens, mprpr );
 	composeCommands ( tokens, mprpr );
 
-	tokens.emplace_back ( PIPELINE_TAG, Token::TokenType::END_ELEMENT );
+	tokens.emplace_back ( PIPELINE_TAG, sax::Token::TokenType::END_ELEMENT );
 }
 
-void MeasurementProvisionerResultsXml::composePipelineStatus ( deque < Token > & tokens, const MPRPipelineResult & mprpr ) {
+void MeasurementProvisionerResultsXml::composePipelineStatus ( std::deque < sax::Token > & tokens, const MPRPipelineResult & mprpr ) {
 
-	tokens.emplace_back ( PIPELINE_STATUS_TAG, Token::TokenType::START_ELEMENT );
-	tokens.emplace_back ( EXIT_CODE_TAG, Token::TokenType::START_ELEMENT );
-	tokens.emplace_back ( std::to_string ( mprpr.pipelineStatus.exitCode ), Token::TokenType::CHARACTER );
-	tokens.emplace_back ( EXIT_CODE_TAG, Token::TokenType::END_ELEMENT );
-	tokens.emplace_back ( ERROR_ORIGIN_TAG, Token::TokenType::START_ELEMENT );
-	tokens.emplace_back ( mprpr.pipelineStatus.errorOrigin, Token::TokenType::CHARACTER );
-	tokens.emplace_back ( ERROR_ORIGIN_TAG, Token::TokenType::END_ELEMENT );
-	tokens.emplace_back ( ERROR_VALUE_TAG, Token::TokenType::START_ELEMENT );
-	tokens.emplace_back ( mprpr.pipelineStatus.errorValue, Token::TokenType::CHARACTER );
-	tokens.emplace_back ( ERROR_VALUE_TAG, Token::TokenType::END_ELEMENT );
+	tokens.emplace_back ( PIPELINE_STATUS_TAG, sax::Token::TokenType::START_ELEMENT );
+	tokens.emplace_back ( EXIT_CODE_TAG, sax::Token::TokenType::START_ELEMENT );
+	tokens.emplace_back ( std::to_string ( mprpr.pipelineStatus.exitCode ), sax::Token::TokenType::CHARACTER );
+	tokens.emplace_back ( EXIT_CODE_TAG, sax::Token::TokenType::END_ELEMENT );
+	tokens.emplace_back ( ERROR_ORIGIN_TAG, sax::Token::TokenType::START_ELEMENT );
+	tokens.emplace_back ( mprpr.pipelineStatus.errorOrigin, sax::Token::TokenType::CHARACTER );
+	tokens.emplace_back ( ERROR_ORIGIN_TAG, sax::Token::TokenType::END_ELEMENT );
+	tokens.emplace_back ( ERROR_VALUE_TAG, sax::Token::TokenType::START_ELEMENT );
+	tokens.emplace_back ( mprpr.pipelineStatus.errorValue, sax::Token::TokenType::CHARACTER );
+	tokens.emplace_back ( ERROR_VALUE_TAG, sax::Token::TokenType::END_ELEMENT );
 
-	tokens.emplace_back ( PIPELINE_STATUS_TAG, Token::TokenType::END_ELEMENT );
+	tokens.emplace_back ( PIPELINE_STATUS_TAG, sax::Token::TokenType::END_ELEMENT );
 }
 
-void MeasurementProvisionerResultsXml::composeCommands ( deque < Token > & tokens, const MPRPipelineResult & mprpr ) {
-	tokens.emplace_back ( COMMANDS_TAG, Token::TokenType::START_ELEMENT );
+void MeasurementProvisionerResultsXml::composeCommands ( std::deque < sax::Token > & tokens, const MPRPipelineResult & mprpr ) {
+	tokens.emplace_back ( COMMANDS_TAG, sax::Token::TokenType::START_ELEMENT );
 
 	for ( const MPRPipelineCommandResult & mprpcr : mprpr.commandResults )
 		composeCommand ( tokens, mprpcr );
 
-	tokens.emplace_back ( COMMANDS_TAG, Token::TokenType::END_ELEMENT );
+	tokens.emplace_back ( COMMANDS_TAG, sax::Token::TokenType::END_ELEMENT );
 }
 
-void MeasurementProvisionerResultsXml::composeCommand ( deque < Token > & tokens, const MPRPipelineCommandResult & mprpcr ) {
-	tokens.emplace_back ( COMMAND_TAG, Token::TokenType::START_ELEMENT );
-	tokens.emplace_back ( COMMAND_NAME_TAG, Token::TokenType::START_ELEMENT );
-	tokens.emplace_back ( mprpcr.command, Token::TokenType::CHARACTER );
-	tokens.emplace_back ( COMMAND_NAME_TAG, Token::TokenType::END_ELEMENT );
+void MeasurementProvisionerResultsXml::composeCommand ( std::deque < sax::Token > & tokens, const MPRPipelineCommandResult & mprpcr ) {
+	tokens.emplace_back ( COMMAND_TAG, sax::Token::TokenType::START_ELEMENT );
+	tokens.emplace_back ( COMMAND_NAME_TAG, sax::Token::TokenType::START_ELEMENT );
+	tokens.emplace_back ( mprpcr.command, sax::Token::TokenType::CHARACTER );
+	tokens.emplace_back ( COMMAND_NAME_TAG, sax::Token::TokenType::END_ELEMENT );
 
 	measurements::MeasurementResultsXml::compose ( mprpcr.measurementResults, tokens );
 
-	tokens.emplace_back ( COMMAND_TAG, Token::TokenType::END_ELEMENT );
+	tokens.emplace_back ( COMMAND_TAG, sax::Token::TokenType::END_ELEMENT );
 }
 
 /*****************************************************************************************************/
 
-MeasurementProvisionerResults MeasurementProvisionerResultsXml::parse ( deque < Token > & tokens ) {
+MeasurementProvisionerResults MeasurementProvisionerResultsXml::parse ( std::deque < sax::Token > & tokens ) {
 	MeasurementProvisionerResults mpr;
 
-	deque < Token >::iterator iter = tokens.begin ( );
+	std::deque < sax::Token >::iterator iter = tokens.begin ( );
 
 	if ( iter == tokens.end ( ) ) throw::exception::CommonException ( "Empty tokens list" );
 
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, MEASUREMENT_PROVISIONER_RESULTS_TAG );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, MEASUREMENT_PROVISIONER_RESULTS_TAG );
 
 	for ( ; ; ) {
-		if ( !FromXMLParserHelper::isTokenType ( iter, Token::TokenType::START_ELEMENT ) ) break;
+		if ( !sax::FromXMLParserHelper::isTokenType ( iter, sax::Token::TokenType::START_ELEMENT ) ) break;
 
-		string data = FromXMLParserHelper::getTokenData ( iter, Token::TokenType::START_ELEMENT );
+		std::string data = sax::FromXMLParserHelper::getTokenData ( iter, sax::Token::TokenType::START_ELEMENT );
 
 		if ( data == MEASUREMENT_PROVISIONER_RESULT_TAG )
 			mpr.inputResults.push_back ( parseMeasurementProvisionerResult ( iter ) );
@@ -124,22 +121,22 @@ MeasurementProvisionerResults MeasurementProvisionerResultsXml::parse ( deque <
 			break;
 	}
 
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, MEASUREMENT_PROVISIONER_RESULTS_TAG );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, MEASUREMENT_PROVISIONER_RESULTS_TAG );
 
-	if ( iter != tokens.end ( ) ) throw::exception::CommonException ( "Unexpeted tokens at the end of the xml" );
+	if ( iter != tokens.end ( ) ) throw::exception::CommonException ( "Unexpected tokens at the end of the XML" );
 
 	return mpr;
 }
 
-MPRInputResult MeasurementProvisionerResultsXml::parseMeasurementProvisionerResult ( deque < Token >::iterator & iter ) {
+MPRInputResult MeasurementProvisionerResultsXml::parseMeasurementProvisionerResult ( std::deque < sax::Token >::iterator & iter ) {
 	MPRInputResult mprir;
 
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, MEASUREMENT_PROVISIONER_RESULT_TAG );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, MEASUREMENT_PROVISIONER_RESULT_TAG );
 
 	for ( ; ; ) {
-		if ( !FromXMLParserHelper::isTokenType ( iter, Token::TokenType::START_ELEMENT ) ) break;
+		if ( !sax::FromXMLParserHelper::isTokenType ( iter, sax::Token::TokenType::START_ELEMENT ) ) break;
 
-		string data = FromXMLParserHelper::getTokenData ( iter, Token::TokenType::START_ELEMENT );
+		std::string data = sax::FromXMLParserHelper::getTokenData ( iter, sax::Token::TokenType::START_ELEMENT );
 
 		if ( data == INPUTS_TAG )
 			parseInputs ( mprir, iter );
@@ -149,47 +146,47 @@ MPRInputResult MeasurementProvisionerResultsXml::parseMeasurementProvisionerResu
 			break;
 	}
 
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, MEASUREMENT_PROVISIONER_RESULT_TAG );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, MEASUREMENT_PROVISIONER_RESULT_TAG );
 
 	return mprir;
 }
 
-void MeasurementProvisionerResultsXml::parseInputs ( MPRInputResult & mprir, deque < Token >::iterator & iter ) {
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, INPUTS_TAG );
+void MeasurementProvisionerResultsXml::parseInputs ( MPRInputResult & mprir, std::deque < sax::Token >::iterator & iter ) {
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, INPUTS_TAG );
 
 	for ( ; ; ) {
-		if ( !FromXMLParserHelper::isTokenType ( iter, Token::TokenType::START_ELEMENT ) ) break;
+		if ( !sax::FromXMLParserHelper::isTokenType ( iter, sax::Token::TokenType::START_ELEMENT ) ) break;
 
-		FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, INPUT_TAG );
+		sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, INPUT_TAG );
 
-		string idAttr = FromXMLParserHelper::getTokenData ( iter, Token::TokenType::START_ATTRIBUTE );
+		std::string idAttr = sax::FromXMLParserHelper::getTokenData ( iter, sax::Token::TokenType::START_ATTRIBUTE );
 
 		if ( idAttr != INPUT_ATTR_ID_NAME )
 			throw::exception::CommonException ( "MPRInputResult Input expects only id attr" );
 
-		FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ATTRIBUTE, idAttr );
+		sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ATTRIBUTE, idAttr );
 
-		int id = stoi ( FromXMLParserHelper::popTokenData ( iter, Token::TokenType::CHARACTER ) );
+		int id = stoi ( sax::FromXMLParserHelper::popTokenData ( iter, sax::Token::TokenType::CHARACTER ) );
 
-		FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ATTRIBUTE, idAttr );
+		sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ATTRIBUTE, idAttr );
 
-		string inputName = FromXMLParserHelper::popTokenData ( iter, Token::TokenType::CHARACTER );
+		std::string inputName = sax::FromXMLParserHelper::popTokenData ( iter, sax::Token::TokenType::CHARACTER );
 
 		mprir.inputs.emplace_back ( id, std::move ( inputName ) );
 
-		FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, INPUT_TAG );
+		sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, INPUT_TAG );
 	}
 
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, INPUTS_TAG );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, INPUTS_TAG );
 }
 
-void MeasurementProvisionerResultsXml::parsePipelines ( MPRInputResult & mprir, deque < Token >::iterator & iter ) {
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, PIPELINES_TAG );
+void MeasurementProvisionerResultsXml::parsePipelines ( MPRInputResult & mprir, std::deque < sax::Token >::iterator & iter ) {
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, PIPELINES_TAG );
 
 	for ( ; ; ) {
-		if ( !FromXMLParserHelper::isTokenType ( iter, Token::TokenType::START_ELEMENT ) ) break;
+		if ( !sax::FromXMLParserHelper::isTokenType ( iter, sax::Token::TokenType::START_ELEMENT ) ) break;
 
-		string data = FromXMLParserHelper::getTokenData ( iter, Token::TokenType::START_ELEMENT );
+		std::string data = sax::FromXMLParserHelper::getTokenData ( iter, sax::Token::TokenType::START_ELEMENT );
 
 		if ( data == PIPELINE_TAG )
 			mprir.pipelineResults.push_back ( parsePipeline ( iter ) );
@@ -197,17 +194,17 @@ void MeasurementProvisionerResultsXml::parsePipelines ( MPRInputResult & mprir,
 			break;
 	}
 
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, PIPELINES_TAG );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, PIPELINES_TAG );
 }
 
-MPRPipelineResult MeasurementProvisionerResultsXml::parsePipeline ( deque < Token >::iterator & iter ) {
+MPRPipelineResult MeasurementProvisionerResultsXml::parsePipeline ( std::deque < sax::Token >::iterator & iter ) {
 	MPRPipelineResult mprpr;
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, PIPELINE_TAG );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, PIPELINE_TAG );
 
 	for ( ; ; ) {
-		if ( !FromXMLParserHelper::isTokenType ( iter, Token::TokenType::START_ELEMENT ) ) break;
+		if ( !sax::FromXMLParserHelper::isTokenType ( iter, sax::Token::TokenType::START_ELEMENT ) ) break;
 
-		string data = FromXMLParserHelper::getTokenData ( iter, Token::TokenType::START_ELEMENT );
+		std::string data = sax::FromXMLParserHelper::getTokenData ( iter, sax::Token::TokenType::START_ELEMENT );
 
 		if ( data == PIPELINE_STATUS_TAG )
 			parsePipelineStatus ( mprpr, iter );
@@ -217,52 +214,52 @@ MPRPipelineResult MeasurementProvisionerResultsXml::parsePipeline ( deque < Toke
 			break;
 	}
 
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, PIPELINE_TAG );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, PIPELINE_TAG );
 
 	return mprpr;
 }
 
-void MeasurementProvisionerResultsXml::parsePipelineStatus ( MPRPipelineResult & mprpr, deque < Token >::iterator & iter ) {
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, PIPELINE_STATUS_TAG );
+void MeasurementProvisionerResultsXml::parsePipelineStatus ( MPRPipelineResult & mprpr, std::deque < sax::Token >::iterator & iter ) {
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, PIPELINE_STATUS_TAG );
 
 	for ( ; ; ) {
-		if ( !FromXMLParserHelper::isTokenType ( iter, Token::TokenType::START_ELEMENT ) ) break;
+		if ( !sax::FromXMLParserHelper::isTokenType ( iter, sax::Token::TokenType::START_ELEMENT ) ) break;
 
-		string data = FromXMLParserHelper::getTokenData ( iter, Token::TokenType::START_ELEMENT );
+		std::string data = sax::FromXMLParserHelper::getTokenData ( iter, sax::Token::TokenType::START_ELEMENT );
 
 		if ( data == EXIT_CODE_TAG ) {
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, EXIT_CODE_TAG );
-			mprpr.pipelineStatus.exitCode = stoi ( FromXMLParserHelper::popTokenData ( iter, Token::TokenType::CHARACTER ) );
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, EXIT_CODE_TAG );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, EXIT_CODE_TAG );
+			mprpr.pipelineStatus.exitCode = stoi ( sax::FromXMLParserHelper::popTokenData ( iter, sax::Token::TokenType::CHARACTER ) );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, EXIT_CODE_TAG );
 		} else if ( data == ERROR_ORIGIN_TAG ) {
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, ERROR_ORIGIN_TAG );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, ERROR_ORIGIN_TAG );
 
-			if ( FromXMLParserHelper::isTokenType ( iter, Token::TokenType::CHARACTER ) )
-				mprpr.pipelineStatus.errorOrigin = FromXMLParserHelper::popTokenData ( iter, Token::TokenType::CHARACTER );
+			if ( sax::FromXMLParserHelper::isTokenType ( iter, sax::Token::TokenType::CHARACTER ) )
+				mprpr.pipelineStatus.errorOrigin = sax::FromXMLParserHelper::popTokenData ( iter, sax::Token::TokenType::CHARACTER );
 
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, ERROR_ORIGIN_TAG );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, ERROR_ORIGIN_TAG );
 		} else if ( data == ERROR_VALUE_TAG ) {
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, ERROR_VALUE_TAG );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, ERROR_VALUE_TAG );
 
-			if ( FromXMLParserHelper::isTokenType ( iter, Token::TokenType::CHARACTER ) )
-				mprpr.pipelineStatus.errorValue = FromXMLParserHelper::popTokenData ( iter, Token::TokenType::CHARACTER );
+			if ( sax::FromXMLParserHelper::isTokenType ( iter, sax::Token::TokenType::CHARACTER ) )
+				mprpr.pipelineStatus.errorValue = sax::FromXMLParserHelper::popTokenData ( iter, sax::Token::TokenType::CHARACTER );
 
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, ERROR_VALUE_TAG );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, ERROR_VALUE_TAG );
 		} else {
 			break;
 		}
 	}
 
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, PIPELINE_STATUS_TAG );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, PIPELINE_STATUS_TAG );
 }
 
-void MeasurementProvisionerResultsXml::parseCommands ( MPRPipelineResult & mprpr, deque < Token >::iterator & iter ) {
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, COMMANDS_TAG );
+void MeasurementProvisionerResultsXml::parseCommands ( MPRPipelineResult & mprpr, std::deque < sax::Token >::iterator & iter ) {
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, COMMANDS_TAG );
 
 	for ( ; ; ) {
-		if ( !FromXMLParserHelper::isTokenType ( iter, Token::TokenType::START_ELEMENT ) ) break;
+		if ( !sax::FromXMLParserHelper::isTokenType ( iter, sax::Token::TokenType::START_ELEMENT ) ) break;
 
-		string data = FromXMLParserHelper::getTokenData ( iter, Token::TokenType::START_ELEMENT );
+		std::string data = sax::FromXMLParserHelper::getTokenData ( iter, sax::Token::TokenType::START_ELEMENT );
 
 		if ( data == COMMAND_TAG )
 			mprpr.commandResults.push_back ( parseCommand ( iter ) );
@@ -270,22 +267,22 @@ void MeasurementProvisionerResultsXml::parseCommands ( MPRPipelineResult & mprpr
 			break;
 	}
 
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, COMMANDS_TAG );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, COMMANDS_TAG );
 }
 
-MPRPipelineCommandResult MeasurementProvisionerResultsXml::parseCommand ( deque < Token >::iterator & iter ) {
+MPRPipelineCommandResult MeasurementProvisionerResultsXml::parseCommand ( std::deque < sax::Token >::iterator & iter ) {
 	MPRPipelineCommandResult mprpcr;
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, COMMAND_TAG );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, COMMAND_TAG );
 
 	for ( ; ; ) {
-		if ( !FromXMLParserHelper::isTokenType ( iter, Token::TokenType::START_ELEMENT ) ) break;
+		if ( !sax::FromXMLParserHelper::isTokenType ( iter, sax::Token::TokenType::START_ELEMENT ) ) break;
 
-		string data = FromXMLParserHelper::getTokenData ( iter, Token::TokenType::START_ELEMENT );
+		std::string data = sax::FromXMLParserHelper::getTokenData ( iter, sax::Token::TokenType::START_ELEMENT );
 
 		if ( data == COMMAND_NAME_TAG ) {
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, COMMAND_NAME_TAG );
-			mprpcr.command = FromXMLParserHelper::popTokenData ( iter, Token::TokenType::CHARACTER );
-			FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, COMMAND_NAME_TAG );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::START_ELEMENT, COMMAND_NAME_TAG );
+			mprpcr.command = sax::FromXMLParserHelper::popTokenData ( iter, sax::Token::TokenType::CHARACTER );
+			sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, COMMAND_NAME_TAG );
 		} else if ( data == MEASUREMENT_RESULTS_TAG ) {
 			mprpcr.measurementResults = measurements::MeasurementResultsXml::parse ( iter );
 		} else {
@@ -293,33 +290,33 @@ MPRPipelineCommandResult MeasurementProvisionerResultsXml::parseCommand ( deque
 		}
 	}
 
-	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, COMMAND_TAG );
+	sax::FromXMLParserHelper::popToken ( iter, sax::Token::TokenType::END_ELEMENT, COMMAND_TAG );
 	return mprpcr;
 }
 
 /*****************************************************************************************************/
 
-string MeasurementProvisionerResultsXml::MEASUREMENT_PROVISIONER_RESULTS_TAG = "MeasurementProvisionerResults";
+std::string MeasurementProvisionerResultsXml::MEASUREMENT_PROVISIONER_RESULTS_TAG = "MeasurementProvisionerResults";
 
-string MeasurementProvisionerResultsXml::MEASUREMENT_PROVISIONER_RESULT_TAG = "MeasurementProvisionerResult";
+std::string MeasurementProvisionerResultsXml::MEASUREMENT_PROVISIONER_RESULT_TAG = "MeasurementProvisionerResult";
 
-string MeasurementProvisionerResultsXml::INPUTS_TAG = "Inputs";
+std::string MeasurementProvisionerResultsXml::INPUTS_TAG = "Inputs";
 
-string MeasurementProvisionerResultsXml::INPUT_TAG = "Input";
-string MeasurementProvisionerResultsXml::INPUT_ATTR_ID_NAME = "id";
+std::string MeasurementProvisionerResultsXml::INPUT_TAG = "Input";
+std::string MeasurementProvisionerResultsXml::INPUT_ATTR_ID_NAME = "id";
 
-string MeasurementProvisionerResultsXml::PIPELINES_TAG = "Pipelines";
-string MeasurementProvisionerResultsXml::PIPELINE_TAG  = "Pipeline";
+std::string MeasurementProvisionerResultsXml::PIPELINES_TAG = "Pipelines";
+std::string MeasurementProvisionerResultsXml::PIPELINE_TAG  = "Pipeline";
 
-string MeasurementProvisionerResultsXml::PIPELINE_STATUS_TAG = "PipelineStatus";
-string MeasurementProvisionerResultsXml::EXIT_CODE_TAG = "ExitCode";
-string MeasurementProvisionerResultsXml::ERROR_ORIGIN_TAG = "ErrorOrigin";
-string MeasurementProvisionerResultsXml::ERROR_VALUE_TAG  = "ErrorValue";
+std::string MeasurementProvisionerResultsXml::PIPELINE_STATUS_TAG = "PipelineStatus";
+std::string MeasurementProvisionerResultsXml::EXIT_CODE_TAG = "ExitCode";
+std::string MeasurementProvisionerResultsXml::ERROR_ORIGIN_TAG = "ErrorOrigin";
+std::string MeasurementProvisionerResultsXml::ERROR_VALUE_TAG  = "ErrorValue";
 
-string MeasurementProvisionerResultsXml::COMMANDS_TAG = "Commands";
-string MeasurementProvisionerResultsXml::COMMAND_TAG  = "Command";
+std::string MeasurementProvisionerResultsXml::COMMANDS_TAG = "Commands";
+std::string MeasurementProvisionerResultsXml::COMMAND_TAG  = "Command";
 
-string MeasurementProvisionerResultsXml::COMMAND_NAME_TAG = "Name";
+std::string MeasurementProvisionerResultsXml::COMMAND_NAME_TAG = "Name";
 
-string MeasurementProvisionerResultsXml::MEASUREMENT_RESULTS_TAG = "MeasurementResults";
+std::string MeasurementProvisionerResultsXml::MEASUREMENT_RESULTS_TAG = "MeasurementResults";
 }