working basic filtering

alib2measurepp/src/processor/MeasurementProcessor.cpp

@@ -3,13 +3,82 @@
  */
 #include "MeasurementProcessor.hpp"
+#include <iostream>
 namespace measurements {
-MeasurementProvisionerResults MeasurementProcessor::process ( MeasurementProvisionerResults mpr, const MeasurementProcessorFilter &  ) {
-	MeasurementProvisionerResults newmpr = std::move ( mpr );
+MeasurementProvisionerResults MeasurementProcessor::process ( MeasurementProvisionerResults mpr, const MeasurementProcessorFilter & filter ) {
+	MeasurementProvisionerResults newmpr;
+
+	for ( MPRResults & mprr : mpr.results ) {
+		MPRResults newmprr;
+		newmprr.inputs = std::move ( mprr.inputs );
+
+		for ( MPRPipelineResults & mprpr : mprr.pipelineResults ) {
+			MPRPipelineResults newmprpr;
+			newmprpr.pipelineStatus = std::move ( mprpr.pipelineStatus );
+
+			for ( MPRPipelineCommandResults & mprpcr : mprpr.commandResults ) {
+
+				 // filter out commands
+				if ( !filter.matches ( MeasurementProcessorFilter::FilterType::COMMAND, mprpcr.command ) ) continue;
+
+				MPRPipelineCommandResults newmprpcr;
+				newmprpcr.command = std::move ( mprpcr.command );
+
+				newmprpcr.measurementResults = processMeasurementResults ( mprpcr.measurementResults, filter );
+
+				newmprpr.commandResults.push_back ( std::move ( newmprpcr ) );
+			}
+
+			if ( newmprpr.commandResults.size ( ) )
+				newmprr.pipelineResults.push_back ( std::move ( newmprpr ) );
+		}
+
+		if ( newmprr.pipelineResults.size ( ) )
+			newmpr.results.push_back ( std::move ( newmprr ) );
+	}
 	return newmpr;
 }
+MeasurementResults MeasurementProcessor::processMeasurementResults ( const MeasurementResults & mr, const MeasurementProcessorFilter & filter ) {
+	MeasurementResults newmr;
+
+	std::function < void ( unsigned, unsigned ) > dfsLambda;
+
+	dfsLambda = [&] ( unsigned idx, unsigned newmrParentIdx ) {
+					if ( idx == 0 ) {
+						newmr.frames.push_back ( mr.frames[0] );
+						newmr.frames[0].sub_idxs.clear ( );
+
+						for ( unsigned subIdx : mr.frames[idx].sub_idxs )
+							dfsLambda ( subIdx, 0 );
+					} else {
+						const MeasurementFrame & curFrame = mr.frames[idx];
+
+						bool filteredOut = false;
+						filteredOut |= !filter.matches ( MeasurementProcessorFilter::FilterType::FRAME_TYPE, to_string ( curFrame.type ) );
+						filteredOut |= !filter.matches ( MeasurementProcessorFilter::FilterType::FRAME_NAME, to_string ( curFrame.name ) );
+
+						if ( !filteredOut ) {
+							unsigned newmrIdx = newmr.frames.size ( );
+							newmr.frames.push_back ( mr.frames[idx] );
+							newmr.frames[newmrIdx].sub_idxs.clear ( );
+							newmr.frames[newmrParentIdx].sub_idxs.push_back ( newmrIdx );
+
+							for ( unsigned subIdx : mr.frames[idx].sub_idxs )
+								dfsLambda ( subIdx, newmrIdx );
+						} else {
+							for ( unsigned subIdx : mr.frames[idx].sub_idxs )
+								dfsLambda ( subIdx, newmrParentIdx );
+						}
+					}
+				};
+
+	dfsLambda ( 0, 0 );
+
+	return newmr;
+}
+
 }

alib2measurepp/src/processor/MeasurementProcessor.hpp

@@ -12,8 +12,11 @@ namespace measurements {
 class MeasurementProcessor {
+	static MeasurementResults processMeasurementResults ( const MeasurementResults &, const MeasurementProcessorFilter & );
+
+
 public:
-	static MeasurementProvisionerResults process(MeasurementProvisionerResults, const MeasurementProcessorFilter &);
+	static MeasurementProvisionerResults process ( MeasurementProvisionerResults, const MeasurementProcessorFilter & );
 };
 }

alib2measurepp/src/processor/MeasurementProcessorFilter.cpp

+/*
+ * Author: Radovan Cerveny
+ */
+
+#include "MeasurementProcessorFilter.hpp"
+
+namespace measurements {
+
+void MeasurementProcessorFilter::add ( FilterType type, const std::string & str ) {
+	filters[type].insert ( str );
+}
+
+void MeasurementProcessorFilter::remove ( FilterType type, const std::string & str ) {
+	filters[type].erase ( str );
+
+	if ( filters[type].empty ( ) ) filters.erase ( type );
+}
+
+bool MeasurementProcessorFilter::matches ( FilterType type, const std::string & str ) const {
+	auto filtersIter = filters.find ( type );
+
+	if ( filtersIter == filters.end ( ) ) return true;
+
+	const auto & filterSet = filtersIter->second;
+
+	return filterSet.find ( str ) != filterSet.end ( );
+}
+
+}

alib2measurepp/src/processor/MeasurementProcessorFilter.hpp

@@ -6,15 +6,25 @@
 #define MEASUREMENT_PROCESSOR_FILTER_HPP_
 #include <map>
-#include <vector>
+#include <set>
 namespace measurements {
-enum class MeasurementProcessorFilterType {
-	FRAME_TYPE,	FRAME_NAME,	COMMAND
+class MeasurementProcessorFilter {
+public:
+	enum class FilterType {
+		FRAME_TYPE,	FRAME_NAME,	COMMAND
+	};
+
+private:
+	std::map < FilterType, std::set < std::string > > filters;
+
+public:
+	void add ( FilterType, const std::string & );
+	void remove ( FilterType, const std::string & );
+	bool matches ( FilterType, const std::string & ) const;
 };
-using MeasurementProcessorFilter = std::map < MeasurementProcessorFilterType, std::vector < std::string > >;
 }
 #endif /* MEASUREMENT_PROCESSOR_FILTER_HPP_ */

alib2measurepp/src/provisioner/MeasurementProvisionerResults.hpp

@@ -12,7 +12,7 @@ namespace measurements {
 struct MPRPipelineCommandResults {
 	std::string						 command;
-	measurements::MeasurementResults measurementResults;
+	MeasurementResults measurementResults;
 };
 struct MPRPipelineStatus {

ameasurep2/src/ameasureproc.cpp

@@ -15,6 +15,7 @@ int main ( int argc, char * * argv ) {
 		TCLAP::CmdLine cmd ( "Measurement processor binary", ' ', "0.01" );
 		std::vector < std::string > allowedOutput;
+		allowedOutput.push_back ( "xml" );
 		allowedOutput.push_back ( "stats" );
 		allowedOutput.push_back ( "csv" );
 		allowedOutput.push_back ( "html" );
@@ -59,13 +60,13 @@ int main ( int argc, char * * argv ) {
 		measurements::MeasurementProcessorFilter filter;
 		for ( const std::string & f : filterByFrameType.getValue ( ) )
-			filter[measurements::MeasurementProcessorFilterType::FRAME_TYPE].push_back ( f );
+			filter.add ( measurements::MeasurementProcessorFilter::FilterType::FRAME_TYPE, f );
 		for ( const std::string & f : filterByFrameName.getValue ( ) )
-			filter[measurements::MeasurementProcessorFilterType::FRAME_NAME].push_back ( f );
+			filter.add ( measurements::MeasurementProcessorFilter::FilterType::FRAME_NAME, f );
 		for ( const std::string & f : filterByCommand.getValue ( ) )
-			filter[measurements::MeasurementProcessorFilterType::COMMAND].push_back ( f );
+			filter.add ( measurements::MeasurementProcessorFilter::FilterType::COMMAND, f );
 		auto processedResults = measurements::MeasurementProcessor::process ( results, filter );