jsoncollector::ObjectMerger Class Reference

#include <ObjectMerger.h>

Static Public Member Functions
static DataPoint *	csvToJson (std::string &olCSV, DataPointDefinition *dpd, std::string defPath)
static bool	getDataPointDefinitionFor (std::string defFilePath, DataPointDefinition &def)
static DataPoint *	merge (const std::vector< DataPoint * > &objectsToMerge, std::string &outcomeMessage, bool onlyHistos)

Static Private Member Functions
static std::string	applyOperation (const std::vector< std::string > &dataVector, std::string operationName)
static bool	checkConsistency (const std::vector< DataPoint * > &objectsToMerge, std::string &outcomeMessage)

Detailed Description

Definition at line 16 of file ObjectMerger.h.

Member Function Documentation

string ObjectMerger::applyOperation ( const std::vector< std::string > &  dataVector, std::string  operationName  )

staticprivate

Definition at line 149 of file ObjectMerger.cc.

References jsoncollector::Operations::avg(), jsoncollector::Operations::AVG, jsoncollector::Operations::cat(), jsoncollector::Operations::CAT, gather_cfg::cout, jsoncollector::Operations::histo(), jsoncollector::Operations::HISTO, jsoncollector::Operations::same(), jsoncollector::Operations::SAME, jsoncollector::Operations::sum(), jsoncollector::Operations::SUM, and jsoncollector::Utils::vectorStringToDouble().

Referenced by merge().

                                 {
    string opResultString = "N/A";

    if (operationName.compare(Operations::SUM) == 0) {
        stringstream ss;
        double opResult = Operations::sum(
                Utils::vectorStringToDouble(dataVector));
        ss << opResult;
        opResultString = ss.str();

    } else if (operationName.compare(Operations::AVG) == 0) {
        stringstream ss;
        double opResult = Operations::avg(
                Utils::vectorStringToDouble(dataVector));
        ss << opResult;
        opResultString = ss.str();
    }
    /*
     * ADD MORE OPERATIONS HERE
     */
    else if (operationName.compare(Operations::SAME) == 0) {
        opResultString = Operations::same(dataVector);
    }

    else if (operationName.compare(Operations::HISTO) == 0) {
        opResultString = Operations::histo(dataVector);
    }

    else if (operationName.compare(Operations::CAT) == 0) {
            opResultString = Operations::cat(dataVector);
        }

    // OPERATION WAS NOT DEFINED
    else {
        cout << "Operation " << operationName << " is NOT DEFINED!" << endl;
    }

    return opResultString;
}

bool ObjectMerger::checkConsistency ( const std::vector< DataPoint * > &  objectsToMerge, std::string &  outcomeMessage  )

staticprivate

Definition at line 190 of file ObjectMerger.cc.

References AlCaHLTBitMon_QueryRunRegistry::getData(), and i.

Referenced by merge().

                                   {

    for (unsigned int i = 0; i < objectsToMerge.size() - 1; i++) {
        // 1. Check if all have the same definition
        if (objectsToMerge[i]->getDefinition().compare(
                objectsToMerge.at(i + 1)->getDefinition()) != 0) {
            outcomeMessage = "JSON files have inconsistent definitions!";
            return false;
        }
        // 2. Check if objects to merge have the same number of elements in data vector
        if (objectsToMerge[i]->getData().size()
                != objectsToMerge.at(i + 1)->getData().size()) {
            outcomeMessage
                    = "JSON files have inconsistent number of elements in the data vector!";
            return false;
        }
    }
    return true;
}

DataPoint * ObjectMerger::csvToJson ( std::string &  olCSV, DataPointDefinition *  dpd, std::string  defPath  )

static

Transforms the CSV string into a DataPoint object using the definition

Definition at line 117 of file ObjectMerger.cc.

References jsoncollector::DataPoint::addToData(), jsoncollector::Utils::bumpIndex(), reco::dp, statics::field, jsoncollector::DataPointDefinition::getLegendFor(), jsoncollector::LegendItem::getOperation(), jsoncollector::Operations::HISTO, timingPdfMaker::histo, i, getHLTprescales::index, jsoncollector::Utils::intArrayToString(), jsoncollector::DataPoint::resetData(), and jsoncollector::DataPoint::setDefinition().

Referenced by jsoncollector::FastMonitor::outputFullHistoDataPoint().

                        {

    DataPoint* dp = new DataPoint();
    dp->setDefinition(defPath);

    vector<string> tokens;
    std::istringstream ss(olCSV);
    while (!ss.eof()) {
        string field;
        getline(ss, field, ',');
        tokens.push_back(field);
    }

    dp->resetData();

    for (unsigned int i = 0; i < tokens.size(); i++) {
        string currentOpName = dpd->getLegendFor(i).getOperation();
        int index = atoi(tokens[i].c_str());
        if (currentOpName.compare(Operations::HISTO) == 0) {
            vector<int> histo;
            Utils::bumpIndex(histo, index);
            string histoStr;
            Utils::intArrayToString(histo, histoStr);
            dp->addToData(histoStr);
        } else
            dp->addToData(tokens[i]);
    }

    return dp;
}

bool ObjectMerger::getDataPointDefinitionFor ( std::string  defFilePath, DataPointDefinition &  def  )

static

Loads DataPointDefinition into the specified reference

Definition at line 103 of file ObjectMerger.cc.

References gather_cfg::cout, jsoncollector::JSONSerializer::deserialize(), and jsoncollector::FileIO::readStringFromFile().

Referenced by jsoncollector::DataPointMonitor::DataPointMonitor(), jsoncollector::FastMonitor::FastMonitor(), and merge().

                                  {
    string dpdString;
    bool readOK = FileIO::readStringFromFile(defFilePath, dpdString);
    // data point definition is bad!
    if (!readOK) {
        cout << "Cannot read from JSON definition path: " << defFilePath
                << endl;
        return false;
    }
    JSONSerializer::deserialize(&dpd, dpdString);
    return true;
}

DataPoint * ObjectMerger::merge ( const std::vector< DataPoint * > &  objectsToMerge, std::string &  outcomeMessage, bool  onlyHistos  )

static

Merges the DataPoint objects in the vector by getting their definition and applying the required operations If the onlyHistos arg is set to true, only histograms will be merged, will for other params the latest value (@ objectsToMerge.size() - 1) will be taken

Definition at line 23 of file ObjectMerger.cc.

References applyOperation(), checkConsistency(), AlCaHLTBitMon_QueryRunRegistry::getData(), getDataPointDefinitionFor(), jsoncollector::DataPointDefinition::getLegend(), jsoncollector::DataPointDefinition::getLegendFor(), jsoncollector::LegendItem::getOperation(), jsoncollector::Operations::HISTO, i, jsoncollector::Utils::matchExactly(), NULL, and source.

Referenced by jsoncollector::FastMonitor::outputFullHistoDataPoint().

                                                 {
    // vector of vectors containing all data in datapoints
    vector<vector<string> > mergedData;

    // check consistency of input files
    if (!checkConsistency(objectsToMerge, outcomeMessage))
        return NULL;

    // 1. Get the definition of these data points
    DataPointDefinition dpd;
    getDataPointDefinitionFor(objectsToMerge.at(0)->getDefinition(), dpd);

    // 1.1 Check if definition has exact no of elements specified
    if (objectsToMerge[0]->getData().size() != dpd.getLegend().size()) {
        outcomeMessage
                = "JSON files and DEFINITION do not have the same number of elements in vectors!";
        //delete dpd;
        return NULL;
    }

    // 2. Assemble merged vector
    for (unsigned int nMetric = 0; nMetric
            < objectsToMerge.at(0)->getData().size(); nMetric++) {
        // 2.1. assemble vector of n-th data elements
        vector<string> metricVector;
        for (unsigned int nObj = 0; nObj < objectsToMerge.size(); nObj++)
            metricVector.push_back(objectsToMerge.at(nObj)->getData()[nMetric]);
        mergedData.push_back(metricVector);
    }

    // 3. Apply defined operation for each measurement in all data points
    vector<string> outputValues;
    for (unsigned int i = 0; i < mergedData.size(); i++) {
        string strVal = "";
        if (onlyHistos) {
            if (Utils::matchExactly(dpd.getLegendFor(i).getOperation(),
                    Operations::HISTO)) {
                strVal = applyOperation(mergedData[i],
                        dpd.getLegendFor(i).getOperation());
            } else {
                strVal = mergedData[i][mergedData[i].size() - 1];
            }

        } else {
            strVal = applyOperation(mergedData[i],
                    dpd.getLegendFor(i).getOperation());

        }
        outputValues.push_back(strVal);
    }

    // 4. Assemble output DataPoint
    /*
     * Change @ 19.06.2013
     * Merging no longer concatenates DataPoint sources.
     * The merged object will contain as source all contributing files,
     * added by the caller class.
     *
     */
    /*
     stringstream ss;
     for (unsigned int i = 0; i < objectsToMerge.size(); i++) {
     ss << objectsToMerge[i]->getSource();
     if (i != objectsToMerge.size(objectsToMerge) - 1)
     ss << ", ";
     }
     string source = ss.str();
     */

    string source = "";
    string definition = objectsToMerge[0]->getDefinition();
    DataPoint* outputDP = new DataPoint(source, definition, outputValues);

    // delete dpd after no longer needed
    //delete dpd;

    return outputDP;
}