From c1a68ce79414693ef327aceab0b906cbd90d1193 Mon Sep 17 00:00:00 2001
From: Tomas Pecka <peckato1@fit.cvut.cz>
Date: Sat, 14 May 2016 12:04:06 +0200
Subject: [PATCH] Measurements: Remove using namespaces (also fix compile)
---
.../measurements/MeasurementResultsXml.cpp | 291 +++++++++---------
.../provisioner/MeasurementProvisioner.cpp | 64 ++--
.../provisioner/MeasurementProvisioner.hpp | 2 +-
...MeasurementProvisionerConfigurationXml.cpp | 145 +++++----
.../MeasurementProvisionerInputData.cpp | 76 +++--
.../MeasurementProvisionerResultsXml.cpp | 243 ++++++++-------
6 files changed, 404 insertions(+), 417 deletions(-)
diff --git a/alib2common/src/measurements/MeasurementResultsXml.cpp b/alib2common/src/measurements/MeasurementResultsXml.cpp
index 81a7edd9c4..945470c022 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 d0108a5a37..c548fc925b 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 6d4e83bfd4..cb0a50b64c 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 8dd15b571f..044d3531a0 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 5882a209fc..9b890995fb 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 f0bf9c1146..1b6be258ae 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";
}
--
GitLab