From c9ccec7db8c1cc83e7a3bce1b4a0c1c685edac4d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Radovan=20=C4=8Cerven=C3=BD?= <radovan.cerveny@gmail.com>
Date: Fri, 4 Mar 2016 23:39:12 +0100
Subject: [PATCH] unified xml naming conventions, added xml parsing of
 provisioning results

---
 .../src/measurements/MeasurementResults.cpp   |   4 +-
 ...lFactory.cpp => MeasurementResultsXml.cpp} |  87 ++++----
 ...lFactory.hpp => MeasurementResultsXml.hpp} |  15 +-
 alib2common/src/measurements/measurements.hpp |   2 +-
 .../measurements/MeasurementsTest.cpp         |  10 +-
 .../test-src/measurements/MeasurementsTest.h  |   4 +-
 ameasure2/src/ameasure.cpp                    |   1 +
 .../provisioner/MeasurementProvisioner.cpp    |   4 +-
 .../MeasurementProvisionerResultsXml.cpp      | 198 +++++++++++++++++-
 .../MeasurementProvisionerResultsXml.hpp      |   9 +
 examples2/measurements/ameasure.xml           |  28 ++-
 11 files changed, 286 insertions(+), 76 deletions(-)
 rename alib2common/src/measurements/{MeasurementXmlFactory.cpp => MeasurementResultsXml.cpp} (87%)
 rename alib2common/src/measurements/{MeasurementXmlFactory.hpp => MeasurementResultsXml.hpp} (85%)

diff --git a/alib2common/src/measurements/MeasurementResults.cpp b/alib2common/src/measurements/MeasurementResults.cpp
index 498072a3e4..ae5ad56ae0 100644
--- a/alib2common/src/measurements/MeasurementResults.cpp
+++ b/alib2common/src/measurements/MeasurementResults.cpp
@@ -2,7 +2,7 @@
  * Author: Radovan Cerveny
  */
 #include "MeasurementResults.hpp"
-#include "MeasurementXmlFactory.hpp"
+#include "MeasurementResultsXml.hpp"
 
 namespace measurements {
 
@@ -118,7 +118,7 @@ std::ostream & operator <<( std::ostream & os, const MeasurementResults & mr ) {
 		break;
 
 	case MeasurementFormat::XML:
-		sax::SaxComposeInterface::printStream ( os, MeasurementXmlFactory::composeMeasurementResults ( mr ) );
+		sax::SaxComposeInterface::printStream ( os, MeasurementResultsXml::compose ( mr ) );
 		break;
 	}
 
diff --git a/alib2common/src/measurements/MeasurementXmlFactory.cpp b/alib2common/src/measurements/MeasurementResultsXml.cpp
similarity index 87%
rename from alib2common/src/measurements/MeasurementXmlFactory.cpp
rename to alib2common/src/measurements/MeasurementResultsXml.cpp
index a8b4db4372..8c541a2cbe 100644
--- a/alib2common/src/measurements/MeasurementXmlFactory.cpp
+++ b/alib2common/src/measurements/MeasurementResultsXml.cpp
@@ -3,7 +3,7 @@
  */
 
 #include "../sax/FromXMLParserHelper.h"
-#include "MeasurementXmlFactory.hpp"
+#include "MeasurementResultsXml.hpp"
 #include "../exception/CommonException.h"
 
 using namespace std;
@@ -11,18 +11,21 @@ using namespace sax;
 
 namespace measurements {
 
-deque < Token > MeasurementXmlFactory::composeMeasurementResults ( const MeasurementResults & mr ) {
+deque < Token > MeasurementResultsXml::compose ( const MeasurementResults & mr ) {
 	deque < 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 );
 
-	MeasurementXmlFactory::composeMeasurementFrames ( tokens, 0, mr.frames );
+	MeasurementResultsXml::composeMeasurementFrames ( tokens, 0, mr.frames );
 
 	tokens.emplace_back ( MEASUREMENT_RESULTS_TAG, Token::TokenType::END_ELEMENT );
-	return tokens;
 }
 
-void MeasurementXmlFactory::composeMeasurementFrames ( deque < Token > & tokens, unsigned idx, const stealth_vector < MeasurementFrame > & frames ) {
+void MeasurementResultsXml::composeMeasurementFrames ( deque < Token > & tokens, unsigned idx, const stealth_vector < MeasurementFrame > & frames ) {
 
 	const MeasurementFrame & frame = frames[idx];
 
@@ -50,7 +53,7 @@ void MeasurementXmlFactory::composeMeasurementFrames ( deque < Token > & tokens,
 	tokens.emplace_back ( MEASUREMENT_FRAME_TAG, Token::TokenType::END_ELEMENT );
 }
 
-void MeasurementXmlFactory::composeTimeDataFrame ( deque < Token > & tokens, unsigned idx, const stealth_vector < MeasurementFrame > & frames ) {
+void MeasurementResultsXml::composeTimeDataFrame ( deque < 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 );
@@ -63,7 +66,7 @@ void MeasurementXmlFactory::composeTimeDataFrame ( deque < Token > & tokens, uns
 	tokens.emplace_back ( TIME_DATA_FRAME_TAG, Token::TokenType::END_ELEMENT );
 }
 
-void MeasurementXmlFactory::composeMemoryDataFrame ( deque < Token > & tokens, unsigned idx, const stealth_vector < MeasurementFrame > & frames ) {
+void MeasurementResultsXml::composeMemoryDataFrame ( deque < 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 );
@@ -82,7 +85,7 @@ void MeasurementXmlFactory::composeMemoryDataFrame ( deque < Token > & tokens, u
 	tokens.emplace_back ( MEMORY_DATA_FRAME_TAG, Token::TokenType::END_ELEMENT );
 }
 
-void MeasurementXmlFactory::composeCounterDataFrame ( deque < Token > & tokens, unsigned idx, const stealth_vector < MeasurementFrame > & frames ) {
+void MeasurementResultsXml::composeCounterDataFrame ( deque < 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 );
@@ -120,25 +123,33 @@ void MeasurementXmlFactory::composeCounterDataFrame ( deque < Token > & tokens,
 	tokens.emplace_back ( COUNTER_DATA_FRAME_TAG, Token::TokenType::END_ELEMENT );
 }
 
-MeasurementResults MeasurementXmlFactory::parseMeasurementResults ( deque < Token > & tokens ) {
+MeasurementResults MeasurementResultsXml::parse ( deque < Token > & tokens ) {
 	MeasurementResults mr;
 
 	deque < 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" );
+
+	return mr;
+}
+
+MeasurementResults MeasurementResultsXml::parse ( deque < Token >::iterator & iter ) {
+	MeasurementResults mr;
+
 	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, MEASUREMENT_RESULTS_TAG );
 
 	parseRootMeasurementFrame ( mr, iter );
 
 	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, MEASUREMENT_RESULTS_TAG );
 
-	if ( iter != tokens.end ( ) ) throw::exception::CommonException ( "Unexpeted tokens at the end of the xml" );
-
 	return mr;
 }
 
-void MeasurementXmlFactory::parseRootMeasurementFrame ( MeasurementResults & mr, deque < Token >::iterator & iter ) {
+void MeasurementResultsXml::parseRootMeasurementFrame ( MeasurementResults & mr, deque < Token >::iterator & iter ) {
 	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, MEASUREMENT_FRAME_TAG );
 
 	mr.frames.emplace_back ( "Root", measurements::Type::ROOT, 0 );
@@ -167,7 +178,7 @@ void MeasurementXmlFactory::parseRootMeasurementFrame ( MeasurementResults & mr,
 	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, MEASUREMENT_FRAME_TAG );
 }
 
-void MeasurementXmlFactory::parseSubframes ( unsigned parentIdx, MeasurementResults & mr, deque < Token >::iterator & iter ) {
+void MeasurementResultsXml::parseSubframes ( unsigned parentIdx, MeasurementResults & mr, deque < Token >::iterator & iter ) {
 	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, MEASUREMENT_SUBFRAMES_TAG );
 
 	for ( ; ; ) {
@@ -184,7 +195,7 @@ void MeasurementXmlFactory::parseSubframes ( unsigned parentIdx, MeasurementResu
 	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, MEASUREMENT_SUBFRAMES_TAG );
 }
 
-void MeasurementXmlFactory::parseMeasurementFrame ( unsigned parentIdx, MeasurementResults & mr, deque < Token >::iterator & iter ) {
+void MeasurementResultsXml::parseMeasurementFrame ( unsigned parentIdx, MeasurementResults & mr, deque < Token >::iterator & iter ) {
 	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, MEASUREMENT_FRAME_TAG );
 
 	unsigned mfIdx = mr.frames.size ( );
@@ -223,7 +234,7 @@ void MeasurementXmlFactory::parseMeasurementFrame ( unsigned parentIdx, Measurem
 	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, MEASUREMENT_FRAME_TAG );
 }
 
-void MeasurementXmlFactory::parseTimeDataFrame ( MeasurementFrame & mf, deque < Token >::iterator & iter ) {
+void MeasurementResultsXml::parseTimeDataFrame ( MeasurementFrame & mf, deque < Token >::iterator & iter ) {
 	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, TIME_DATA_FRAME_TAG );
 
 	for ( ; ; ) {
@@ -247,7 +258,7 @@ void MeasurementXmlFactory::parseTimeDataFrame ( MeasurementFrame & mf, deque <
 	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, TIME_DATA_FRAME_TAG );
 }
 
-void MeasurementXmlFactory::parseMemoryDataFrame ( MeasurementFrame & mf, deque < Token >::iterator & iter ) {
+void MeasurementResultsXml::parseMemoryDataFrame ( MeasurementFrame & mf, deque < Token >::iterator & iter ) {
 	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, MEMORY_DATA_FRAME_TAG );
 
 	for ( ; ; ) {
@@ -279,7 +290,7 @@ void MeasurementXmlFactory::parseMemoryDataFrame ( MeasurementFrame & mf, deque
 	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, MEMORY_DATA_FRAME_TAG );
 }
 
-void MeasurementXmlFactory::parseCounterDataFrame ( MeasurementFrame & mf, deque < Token >::iterator & iter ) {
+void MeasurementResultsXml::parseCounterDataFrame ( MeasurementFrame & mf, deque < Token >::iterator & iter ) {
 	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, COUNTER_DATA_FRAME_TAG );
 
 	for ( ; ; ) {
@@ -298,7 +309,7 @@ void MeasurementXmlFactory::parseCounterDataFrame ( MeasurementFrame & mf, deque
 	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, COUNTER_DATA_FRAME_TAG );
 }
 
-void MeasurementXmlFactory::parseCounterDataFrameCounters ( const std::string & tag, stealth_map < stealth_string, CounterHint::value_type > & counters, std::deque < sax::Token >::iterator & iter ) {
+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 );
 
 	for ( ; ; ) {
@@ -343,7 +354,7 @@ void MeasurementXmlFactory::parseCounterDataFrameCounters ( const std::string &
 }
 
 template < typename T >
-T MeasurementXmlFactory::valueTypeFromString ( const std::string & str ) {
+T MeasurementResultsXml::valueTypeFromString ( const std::string & str ) {
 	istringstream iss ( str );
 	T val;
 
@@ -351,28 +362,28 @@ T MeasurementXmlFactory::valueTypeFromString ( const std::string & str ) {
 	return val;
 }
 
-std::string MeasurementXmlFactory::MEASUREMENT_RESULTS_TAG = "MeasurementResults";
+std::string MeasurementResultsXml::MEASUREMENT_RESULTS_TAG = "MeasurementResults";
 
-std::string MeasurementXmlFactory::MEASUREMENT_FRAME_TAG = "MeasurementFrame";
-std::string MeasurementXmlFactory::MEASUREMENT_FRAME_NAME_TAG = "Name";
-std::string MeasurementXmlFactory::MEASUREMENT_FRAME_TYPE_TAG = "Type";
+std::string MeasurementResultsXml::MEASUREMENT_FRAME_TAG = "MeasurementFrame";
+std::string MeasurementResultsXml::MEASUREMENT_FRAME_NAME_TAG = "Name";
+std::string MeasurementResultsXml::MEASUREMENT_FRAME_TYPE_TAG = "Type";
 
-std::string MeasurementXmlFactory::MEASUREMENT_SUBFRAMES_TAG = "SubFrames";
+std::string MeasurementResultsXml::MEASUREMENT_SUBFRAMES_TAG = "SubFrames";
 
-std::string MeasurementXmlFactory::TIME_DATA_FRAME_TAG = "TimeData";
-std::string MeasurementXmlFactory::TIME_DATA_FRAME_DURATION_TAG = "Duration";
-std::string MeasurementXmlFactory::TIME_DATA_FRAME_IN_FRAME_DURATION_TAG = "InFrameDuration";
+std::string MeasurementResultsXml::TIME_DATA_FRAME_TAG = "TimeData";
+std::string MeasurementResultsXml::TIME_DATA_FRAME_DURATION_TAG = "Duration";
+std::string MeasurementResultsXml::TIME_DATA_FRAME_IN_FRAME_DURATION_TAG = "InFrameDuration";
 
-std::string MeasurementXmlFactory::MEMORY_DATA_FRAME_TAG = "MemoryData";
-std::string MeasurementXmlFactory::MEMORY_DATA_FRAME_START_HEAP_USAGE_TAG = "StartHeapUsage";
-std::string MeasurementXmlFactory::MEMORY_DATA_FRAME_END_HEAP_USAGE_TAG = "EndHeapUsage";
-std::string MeasurementXmlFactory::MEMORY_DATA_FRAME_HIGH_WATERMARK_TAG = "HighWatermark";
-std::string MeasurementXmlFactory::MEMORY_DATA_FRAME_IN_FRAME_HIGH_WATERMARK_TAG = "InFrameHighWatermark";
+std::string MeasurementResultsXml::MEMORY_DATA_FRAME_TAG = "MemoryData";
+std::string MeasurementResultsXml::MEMORY_DATA_FRAME_START_HEAP_USAGE_TAG = "StartHeapUsage";
+std::string MeasurementResultsXml::MEMORY_DATA_FRAME_END_HEAP_USAGE_TAG = "EndHeapUsage";
+std::string MeasurementResultsXml::MEMORY_DATA_FRAME_HIGH_WATERMARK_TAG = "HighWatermark";
+std::string MeasurementResultsXml::MEMORY_DATA_FRAME_IN_FRAME_HIGH_WATERMARK_TAG = "InFrameHighWatermark";
 
-std::string MeasurementXmlFactory::COUNTER_DATA_FRAME_TAG = "CounterData";
-std::string MeasurementXmlFactory::COUNTER_DATA_FRAME_COUNTERS_TAG = "Counters";
-std::string MeasurementXmlFactory::COUNTER_DATA_FRAME_IN_FRAME_COUNTERS_TAG = "InFrameCounters";
-std::string MeasurementXmlFactory::COUNTER_DATA_FRAME_COUNTER_TAG = "Counter";
-std::string MeasurementXmlFactory::COUNTER_DATA_FRAME_COUNTER_NAME_TAG	= "Name";
-std::string MeasurementXmlFactory::COUNTER_DATA_FRAME_COUNTER_VALUE_TAG = "Value";
+std::string MeasurementResultsXml::COUNTER_DATA_FRAME_TAG = "CounterData";
+std::string MeasurementResultsXml::COUNTER_DATA_FRAME_COUNTERS_TAG = "Counters";
+std::string MeasurementResultsXml::COUNTER_DATA_FRAME_IN_FRAME_COUNTERS_TAG = "InFrameCounters";
+std::string MeasurementResultsXml::COUNTER_DATA_FRAME_COUNTER_TAG = "Counter";
+std::string MeasurementResultsXml::COUNTER_DATA_FRAME_COUNTER_NAME_TAG	= "Name";
+std::string MeasurementResultsXml::COUNTER_DATA_FRAME_COUNTER_VALUE_TAG = "Value";
 }
diff --git a/alib2common/src/measurements/MeasurementXmlFactory.hpp b/alib2common/src/measurements/MeasurementResultsXml.hpp
similarity index 85%
rename from alib2common/src/measurements/MeasurementXmlFactory.hpp
rename to alib2common/src/measurements/MeasurementResultsXml.hpp
index aec56d8956..219470bd50 100644
--- a/alib2common/src/measurements/MeasurementXmlFactory.hpp
+++ b/alib2common/src/measurements/MeasurementResultsXml.hpp
@@ -2,8 +2,8 @@
  * Author: Radovan Cerveny
  */
 
-#ifndef MEASUREMENT_PROVISIONER_XML_FACTORY_HPP_
-#define MEASUREMENT_PROVISIONER_XML_FACTORY_HPP_
+#ifndef MEASUREMENT_RESULTS_XML_HPP_
+#define MEASUREMENT_RESULTS_XML_HPP_
 
 #include <deque>
 #include "../sax/Token.h"
@@ -11,7 +11,7 @@
 
 namespace measurements {
 
-class MeasurementXmlFactory {
+class MeasurementResultsXml {
 
 	static std::string MEASUREMENT_RESULTS_TAG;
 
@@ -58,10 +58,13 @@ class MeasurementXmlFactory {
 	static T valueTypeFromString ( const std::string & );
 
 public:
-	static std::deque < sax::Token > composeMeasurementResults ( const MeasurementResults & );
-	static MeasurementResults parseMeasurementResults ( std::deque < sax::Token > & );
+	static std::deque < sax::Token > compose ( const MeasurementResults & );
+	static void compose ( const MeasurementResults &, std::deque < sax::Token > & );
+
+	static MeasurementResults parse ( std::deque < sax::Token > & );
+	static MeasurementResults parse ( std::deque < sax::Token >::iterator & );
 };
 
 }
 
-#endif /* MEASUREMENT_PROVISIONER_XML_FACTORY_HPP_ */
+#endif /* MEASUREMENT_RESULTS_XML_HPP_ */
diff --git a/alib2common/src/measurements/measurements.hpp b/alib2common/src/measurements/measurements.hpp
index aed9fdecbe..d0a2d9a9ed 100644
--- a/alib2common/src/measurements/measurements.hpp
+++ b/alib2common/src/measurements/measurements.hpp
@@ -6,7 +6,7 @@
 #define MEASUREMENTS_HPP_
 
 #include "MeasurementEngine.hpp"
-#include "MeasurementXmlFactory.hpp"
+#include "MeasurementResultsXml.hpp"
 
 namespace measurements {
 
diff --git a/alib2common/test-src/measurements/MeasurementsTest.cpp b/alib2common/test-src/measurements/MeasurementsTest.cpp
index 96fb460c0c..2e2e421158 100644
--- a/alib2common/test-src/measurements/MeasurementsTest.cpp
+++ b/alib2common/test-src/measurements/MeasurementsTest.cpp
@@ -87,8 +87,8 @@ void MeasurementsTest::testMemoryMeasurements ( ) {
 
 	measurements::start ( "chunk3", measurements::Type::MAIN );
 	measurements::start ( "chunk31", measurements::Type::MAIN );
-		bar = new int[1000];
-		delete[] bar;
+	bar = new int[1000];
+	delete[] bar;
 	measurements::end ( );
 	measurements::end ( );
 
@@ -124,7 +124,7 @@ void MeasurementsTest::testCounterMeasurements ( ) {
 	std::cout << measurements::MeasurementFormat::XML << measurements::results ( ) << std::endl;
 }
 
-void MeasurementsTest::testMeasurementXmlFactory ( ) {
+void MeasurementsTest::testMeasurementResultsXml ( ) {
 	measurements::start ( "global", measurements::Type::OVERALL );
 	measurements::start ( "init", measurements::Type::INIT );
 	std::this_thread::sleep_for ( std::chrono::milliseconds ( 100 ) );
@@ -187,9 +187,9 @@ void MeasurementsTest::testMeasurementXmlFactory ( ) {
 	measurements::end ( );
 	measurements::end ( );
 
-	std::deque < sax::Token > tokens = measurements::MeasurementXmlFactory::composeMeasurementResults ( measurements::results ( ) );
+	std::deque < sax::Token > tokens = measurements::MeasurementResultsXml::compose ( measurements::results ( ) );
 
-	measurements::MeasurementResults convertedResults = measurements::MeasurementXmlFactory::parseMeasurementResults ( tokens );
+	measurements::MeasurementResults convertedResults = measurements::MeasurementResultsXml::parse ( tokens );
 
 	std::ostringstream ossoriginal;
 
diff --git a/alib2common/test-src/measurements/MeasurementsTest.h b/alib2common/test-src/measurements/MeasurementsTest.h
index 25a10d4897..77a90dd673 100644
--- a/alib2common/test-src/measurements/MeasurementsTest.h
+++ b/alib2common/test-src/measurements/MeasurementsTest.h
@@ -9,7 +9,7 @@ class MeasurementsTest : public CppUnit::TestFixture {
   CPPUNIT_TEST ( testTimeMeasurements );
   CPPUNIT_TEST ( testMemoryMeasurements );
   CPPUNIT_TEST ( testCounterMeasurements );
-  CPPUNIT_TEST ( testMeasurementXmlFactory );
+  CPPUNIT_TEST ( testMeasurementResultsXml );
   CPPUNIT_TEST_SUITE_END ( );
 
 public:
@@ -21,7 +21,7 @@ public:
   void testMemoryMeasurements ( );
   void testCounterMeasurements ( );
 
-  void testMeasurementXmlFactory ( );
+  void testMeasurementResultsXml( );
 };
 
 #endif // MEASUREMENTS_TEST_H_
diff --git a/ameasure2/src/ameasure.cpp b/ameasure2/src/ameasure.cpp
index 7a28a4a14a..f91c39d01f 100644
--- a/ameasure2/src/ameasure.cpp
+++ b/ameasure2/src/ameasure.cpp
@@ -3,6 +3,7 @@
  */
 
 #include "provisioner/MeasurementProvisionerConfigurationXml.hpp"
+#include "provisioner/MeasurementProvisionerResultsXml.hpp"
 #include "provisioner/MeasurementProvisioner.hpp"
 #include "factory/XmlDataFactory.hpp"
 #include <tclap/CmdLine.h>
diff --git a/ameasure2/src/provisioner/MeasurementProvisioner.cpp b/ameasure2/src/provisioner/MeasurementProvisioner.cpp
index e49d88a206..5a5b8e0cc3 100644
--- a/ameasure2/src/provisioner/MeasurementProvisioner.cpp
+++ b/ameasure2/src/provisioner/MeasurementProvisioner.cpp
@@ -170,9 +170,7 @@ MPRPipelineResults MeasurementProvisioner::runPipeline ( const MPPipeline & pipe
 			deque < sax::Token > tokens;
 			sax::SaxParseInterface::parseStream ( ifd, tokens );
 
-			measurements::MeasurementResults measurementResults = measurements::MeasurementXmlFactory::parseMeasurementResults ( tokens );
-
-			// ofdlog << measurements::MeasurementFormat::TREE << measurementResults << endl;
+			measurements::MeasurementResults measurementResults = measurements::MeasurementResultsXml::parse ( tokens );
 
 			pipelineResults.commandResults.push_back ( { mppcIter->getRawCommand ( ), std::move ( measurementResults ) } );
 
diff --git a/ameasure2/src/provisioner/MeasurementProvisionerResultsXml.cpp b/ameasure2/src/provisioner/MeasurementProvisionerResultsXml.cpp
index ac2be88969..8f6e0c4549 100644
--- a/ameasure2/src/provisioner/MeasurementProvisionerResultsXml.cpp
+++ b/ameasure2/src/provisioner/MeasurementProvisionerResultsXml.cpp
@@ -3,6 +3,8 @@
  */
 
 #include "MeasurementProvisionerResultsXml.hpp"
+#include "exception/CommonException.h"
+#include "sax/FromXMLParserHelper.h"
 #include <measure>
 
 using namespace std;
@@ -95,14 +97,202 @@ void MeasurementProvisionerResultsXml::composeCommand ( deque < Token > & tokens
 	tokens.emplace_back ( mprpcr.command, Token::TokenType::CHARACTER );
 	tokens.emplace_back ( COMMAND_NAME_TAG, Token::TokenType::END_ELEMENT );
 
-	deque < Token > measurementResultsTokens = measurements::MeasurementXmlFactory::composeMeasurementResults ( mprpcr.measurementResults );
-
-	for ( Token & tok : measurementResultsTokens )
-		tokens.emplace_back ( std::move ( tok ) );
+	measurements::MeasurementResultsXml::compose ( mprpcr.measurementResults, tokens );
 
 	tokens.emplace_back ( COMMAND_TAG, Token::TokenType::END_ELEMENT );
 }
 
+/*****************************************************************************************************/
+
+MeasurementProvisionerResults MeasurementProvisionerResultsXml::parse ( deque < Token > & tokens ) {
+	MeasurementProvisionerResults mprs;
+
+	deque < 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 );
+
+	for ( ; ; ) {
+		if ( !FromXMLParserHelper::isTokenType ( iter, Token::TokenType::START_ELEMENT ) ) break;
+
+		string data = FromXMLParserHelper::getTokenData ( iter, Token::TokenType::START_ELEMENT );
+
+		if ( data == MEASUREMENT_PROVISIONER_RESULT_TAG )
+			mprs.results.push_back ( parseMeasurementProvisionerResult ( iter ) );
+		else
+			break;
+	}
+
+	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, MEASUREMENT_PROVISIONER_RESULTS_TAG );
+
+	if ( iter != tokens.end ( ) ) throw::exception::CommonException ( "Unexpeted tokens at the end of the xml" );
+
+	return mprs;
+}
+
+MPRResults MeasurementProvisionerResultsXml::parseMeasurementProvisionerResult ( deque < Token >::iterator & iter ) {
+	MPRResults mprr;
+
+	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, MEASUREMENT_PROVISIONER_RESULT_TAG );
+
+	for ( ; ; ) {
+		if ( !FromXMLParserHelper::isTokenType ( iter, Token::TokenType::START_ELEMENT ) ) break;
+
+		string data = FromXMLParserHelper::getTokenData ( iter, Token::TokenType::START_ELEMENT );
+
+		if ( data == INPUTS_TAG )
+			parseInputs ( mprr, iter );
+		else if ( data == PIPELINES_TAG )
+			parsePipelines ( mprr, iter );
+		else
+			break;
+	}
+
+	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, MEASUREMENT_PROVISIONER_RESULT_TAG );
+
+	return mprr;
+}
+
+void MeasurementProvisionerResultsXml::parseInputs ( MPRResults & mprr, deque < Token >::iterator & iter ) {
+	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, INPUTS_TAG );
+
+	for ( ; ; ) {
+		if ( !FromXMLParserHelper::isTokenType ( iter, Token::TokenType::START_ELEMENT ) ) break;
+
+		FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, INPUT_TAG );
+
+		string idAttr = FromXMLParserHelper::getTokenData ( iter, Token::TokenType::START_ATTRIBUTE );
+
+		if ( idAttr != INPUT_ATTR_ID_NAME )
+			throw::exception::CommonException ( "MPRResults Input expects only id attr" );
+
+		FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ATTRIBUTE, idAttr );
+
+		int id = stoi ( FromXMLParserHelper::popTokenData ( iter, Token::TokenType::CHARACTER ) );
+
+		FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ATTRIBUTE, idAttr );
+
+		string inputName = FromXMLParserHelper::popTokenData ( iter, Token::TokenType::CHARACTER );
+
+		mprr.inputs.emplace_back ( id, std::move ( inputName ) );
+
+		FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, INPUT_TAG );
+	}
+
+	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, INPUTS_TAG );
+}
+
+void MeasurementProvisionerResultsXml::parsePipelines ( MPRResults & mprr, deque < Token >::iterator & iter ) {
+	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, PIPELINES_TAG );
+
+	for ( ; ; ) {
+		if ( !FromXMLParserHelper::isTokenType ( iter, Token::TokenType::START_ELEMENT ) ) break;
+
+		string data = FromXMLParserHelper::getTokenData ( iter, Token::TokenType::START_ELEMENT );
+
+		if ( data == PIPELINE_TAG )
+			mprr.pipelineResults.push_back ( parsePipeline ( iter ) );
+		else
+			break;
+	}
+
+	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, PIPELINES_TAG );
+}
+
+MPRPipelineResults MeasurementProvisionerResultsXml::parsePipeline ( deque < Token >::iterator & iter ) {
+	MPRPipelineResults mprpr;
+	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, PIPELINE_TAG );
+
+	for ( ; ; ) {
+		if ( !FromXMLParserHelper::isTokenType ( iter, Token::TokenType::START_ELEMENT ) ) break;
+
+		string data = FromXMLParserHelper::getTokenData ( iter, Token::TokenType::START_ELEMENT );
+
+		if ( data == PIPELINE_STATUS_TAG )
+			parsePipelineStatus ( mprpr, iter );
+		else if ( data == COMMANDS_TAG )
+			parseCommands ( mprpr, iter );
+		else
+			break;
+	}
+
+	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, PIPELINE_TAG );
+
+	return mprpr;
+}
+
+void MeasurementProvisionerResultsXml::parsePipelineStatus ( MPRPipelineResults & mprpr, deque < Token >::iterator & iter ) {
+	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, PIPELINE_STATUS_TAG );
+
+	for ( ; ; ) {
+		if ( !FromXMLParserHelper::isTokenType ( iter, Token::TokenType::START_ELEMENT ) ) break;
+
+		string data = FromXMLParserHelper::getTokenData ( iter, 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 );
+		} else if ( data == ERROR_ORIGIN_TAG ) {
+			FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, ERROR_ORIGIN_TAG );
+			mprpr.pipelineStatus.errorOrigin = FromXMLParserHelper::popTokenData ( iter, Token::TokenType::CHARACTER );
+			FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, ERROR_ORIGIN_TAG );
+		} else if ( data == ERROR_VALUE_TAG ) {
+			FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, ERROR_VALUE_TAG );
+			mprpr.pipelineStatus.errorValue = FromXMLParserHelper::popTokenData ( iter, Token::TokenType::CHARACTER );
+			FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, ERROR_VALUE_TAG );
+		} else {
+			break;
+		}
+	}
+
+	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, PIPELINE_STATUS_TAG );
+}
+
+void MeasurementProvisionerResultsXml::parseCommands ( MPRPipelineResults & mprpr, deque < Token >::iterator & iter ) {
+	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, COMMANDS_TAG );
+
+	for ( ; ; ) {
+		if ( !FromXMLParserHelper::isTokenType ( iter, Token::TokenType::START_ELEMENT ) ) break;
+
+		string data = FromXMLParserHelper::getTokenData ( iter, Token::TokenType::START_ELEMENT );
+
+		if ( data == COMMAND_TAG )
+			mprpr.commandResults.push_back ( parseCommand ( iter ) );
+		else
+			break;
+	}
+
+	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, COMMANDS_TAG );
+}
+
+MPRPipelineCommandResults MeasurementProvisionerResultsXml::parseCommand ( deque < Token >::iterator & iter ) {
+	MPRPipelineCommandResults mprpcr;
+	FromXMLParserHelper::popToken ( iter, Token::TokenType::START_ELEMENT, COMMAND_TAG );
+
+	for ( ; ; ) {
+		if ( !FromXMLParserHelper::isTokenType ( iter, Token::TokenType::START_ELEMENT ) ) break;
+
+		string data = FromXMLParserHelper::getTokenData ( iter, 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 );
+		} else if ( data == MEASUREMENT_RESULTS_TAG ) {
+			mprpcr.measurementResults = measurements::MeasurementResultsXml::parse ( iter );
+		} else {
+			break;
+		}
+	}
+
+	FromXMLParserHelper::popToken ( iter, Token::TokenType::END_ELEMENT, COMMAND_TAG );
+	return mprpcr;
+}
+
+/*****************************************************************************************************/
+
 string MeasurementProvisionerResultsXml::MEASUREMENT_PROVISIONER_RESULTS_TAG = "MeasurementProvisionerResults";
 
 string MeasurementProvisionerResultsXml::MEASUREMENT_PROVISIONER_RESULT_TAG = "MeasurementProvisionerResult";
diff --git a/ameasure2/src/provisioner/MeasurementProvisionerResultsXml.hpp b/ameasure2/src/provisioner/MeasurementProvisionerResultsXml.hpp
index 89b3566340..f74a702483 100644
--- a/ameasure2/src/provisioner/MeasurementProvisionerResultsXml.hpp
+++ b/ameasure2/src/provisioner/MeasurementProvisionerResultsXml.hpp
@@ -43,8 +43,17 @@ class MeasurementProvisionerResultsXml {
 	static void composeCommands ( std::deque < sax::Token > &, const MPRPipelineResults & );
 	static void composeCommand ( std::deque < sax::Token > &, const MPRPipelineCommandResults & );
 
+	static MPRResults parseMeasurementProvisionerResult ( std::deque < sax::Token >::iterator & );
+	static void parseInputs ( MPRResults &, std::deque < sax::Token >::iterator & );
+	static void parsePipelines ( MPRResults &, std::deque < sax::Token >::iterator & );
+	static MPRPipelineResults parsePipeline ( std::deque < sax::Token >::iterator & );
+	static void parsePipelineStatus ( MPRPipelineResults &, std::deque < sax::Token >::iterator & );
+	static void parseCommands ( MPRPipelineResults &, std::deque < sax::Token >::iterator & );
+	static MPRPipelineCommandResults parseCommand ( std::deque < sax::Token >::iterator & );
+
 public:
 	static std::deque < sax::Token > compose ( const MeasurementProvisionerResults & );
+	static MeasurementProvisionerResults parse ( std::deque < sax::Token > & );
 };
 
 }
diff --git a/examples2/measurements/ameasure.xml b/examples2/measurements/ameasure.xml
index 7e28dce01c..3134ea8521 100644
--- a/examples2/measurements/ameasure.xml
+++ b/examples2/measurements/ameasure.xml
@@ -4,27 +4,25 @@
 	<MeasurementProvision>
 		<InputData>
 			<InputBatch>
-				<File id="1">~/repositories/automata-library/local/examples/data[1-9].xml</File>
-				<File id="2">~/repositories/automata-library/local/examples/data[1-9].pattern.xml</File>
-			</InputBatch>
-			<InputBatch>
-				<Generator id="1">./arand2 -t ST --length 1024 --terminals 26</Generator>
-				<Generator id="2">./arand2 -t ST --length 1024 --terminals 26</Generator>
-			</InputBatch>
-			<InputBatch dependency="true">
-				<Generator id="1" count="2">./arand2 -t ST --length 1024 --terminals 26</Generator>
-				<File id="2">~/repositories/automata-library/local/examples/data[1-9].pattern.xml</File>
-				</InputBatch>
-			<InputBatch>
-				<Generator id="1" count="2">./arand2 -t ST --length 1024 --terminals 26</Generator>
-				<Generator id="2" count="2">./arand2 -t ST --length 256 --terminals 26 # -i $1</Generator>
-				<Generator id="2" count="2">./arand2 -t ST --length 512 --terminals 26 # -i $1"</Generator>
+				<Generator id="1">./arand2 -t ST --length 16384 --terminals 2</Generator>
+				<Generator id="1">./arand2 -t ST --length 16384 --terminals 4</Generator>
+				<Generator id="1">./arand2 -t ST --length 16384 --terminals 26</Generator>
+				<Generator id="2">./arand2 -t SST --length 64 -i $1</Generator>
+				<Generator id="2">./arand2 -t SST --length 128 -i $1</Generator>
+				<Generator id="2">./arand2 -t SST --length 256 -i $1</Generator>
+				<Generator id="2">./arand2 -t SST --length 512 -i $1</Generator>
 			</InputBatch>
 		</InputData>
 		<Pipelines>
+			<Pipeline>
+				<Command >./astringology2 -a exactFactorMatch -s $1 -p $2</Command>
+			</Pipeline>
 			<Pipeline>
 				<Command >./astringology2 -a boyerMooreHorspool -s $1 -p $2</Command>
 			</Pipeline>
+			<Pipeline>
+				<Command >./astringology2 -a reversedBoyerMooreHorspool -s $1 -p $2</Command>
+			</Pipeline>
 			<Pipeline>
 				<Command >./astringology2 -a deadZoneUsingBadCharacterShift -s $1 -p $2</Command>
 			</Pipeline>
-- 
GitLab