CMSSW_4_4_3_patch1/src/DQMServices/ClientConfig/src/QTestConfigurationParser.cc

Go to the documentation of this file.

#include "DQMServices/ClientConfig/interface/QTestConfigurationParser.h"
#include "DQMServices/ClientConfig/interface/QTestParameterNames.h"
#include "DQMServices/ClientConfig/interface/ParserFunctions.h"
#include <cstring>
#include <stdexcept>         
using namespace xercesc;

int QTestConfigurationParser::s_numberOfInstances = 0;


QTestConfigurationParser::QTestConfigurationParser(){
        
        qtestParamNames=new QTestParameterNames();

        try { 
                if (s_numberOfInstances==0) 
                XMLPlatformUtils::Initialize();  
        }
        catch (const XMLException& e) {
                throw(std::runtime_error("Standard pool exception : Fatal Error on pool::TrivialFileCatalog"));
        }
 
        ++s_numberOfInstances;
}

QTestConfigurationParser::~QTestConfigurationParser(){
        delete qtestParamNames;
        qtestParamNames = 0;
}

bool QTestConfigurationParser::parseQTestsConfiguration(){
        testsToDisable.clear();
        testsRequested.clear();
        mapMonitorElementTests.clear();
        bool qtErrors= this->qtestsConfig();
        bool meErrors= this->monitorElementTestsMap();
        return (qtErrors||meErrors);

}

bool QTestConfigurationParser::qtestsConfig(){
        
        std::string testActivationOFF="false";

        unsigned int qtestTagsNum  = 
          doc()->getElementsByTagName(qtxml::_toDOMS("QTEST"))->getLength();

        for (unsigned int i=0; i<qtestTagsNum; ++i){
                DOMNode* qtestNode = 
                  doc()->getElementsByTagName(qtxml::_toDOMS("QTEST"))->item(i);
        
        
                if (! qtestNode){
                        return true;
                }
                DOMElement* qtestElement = static_cast<DOMElement *>(qtestNode);          
                if (! qtestElement){
                        return true;             
                }
                std::string qtestName = qtxml::_toString (qtestElement->getAttribute (qtxml::_toDOMS ("name"))); 
                std::string activate = qtxml::_toString (qtestElement->getAttribute (qtxml::_toDOMS ("activate"))); 
                if(!std::strcmp(activate.c_str(),testActivationOFF.c_str())) {
                        testsToDisable.push_back(qtestName);
                }else{  
                                                        
                        DOMNodeList *typeNodePrefix 
                        = qtestElement->getElementsByTagName (qtxml::_toDOMS ("TYPE"));
                     
                        if (typeNodePrefix->getLength () != 1)return true;
                               
             
                        DOMElement *prefixNode = dynamic_cast <DOMElement *> (typeNodePrefix->item (0));
                        if (!prefixNode)return true;

                        DOMText *prefixText = dynamic_cast <DOMText *> (prefixNode->getFirstChild());
                        if (!prefixText)return true;                    
        
                        std::string qtestType = qtxml::_toString (prefixText->getData ());

                        testsRequested[qtestName]=  this->getParams(qtestElement, qtestType);
                
                        if( this->checkParameters(qtestName, qtestType)) return true;
                }
        
        } //loop on qtestTagsNum
 
        return false;
 
}

std::map<std::string, std::string> QTestConfigurationParser::getParams(DOMElement* qtestElement, std::string qtestType){
        
        std::map<std::string, std::string> paramNamesValues;
        paramNamesValues["type"]=qtestType;
        
        DOMNodeList *arguments = qtestElement->getElementsByTagName (qtxml::_toDOMS ("PARAM"));
        
        for (unsigned int i=0; i<arguments->getLength(); ++i){
                DOMElement *argNode = dynamic_cast <DOMElement *> ( arguments ->item(i));
                std::string regExp = qtxml::_toString (argNode->getAttribute (qtxml::_toDOMS ("name"))); 
                DOMText *argText = dynamic_cast <DOMText *> (argNode->getFirstChild());
                if (!argText){
                        break;
                }
           
                std::string regExpValue = qtxml::_toString (argText->getData());
                paramNamesValues[regExp]=regExpValue;
        }
        
        return paramNamesValues;

}

bool QTestConfigurationParser::checkParameters(std::string qtestName, std::string qtestType){
        
        std::vector<std::string> paramNames=qtestParamNames->getTestParamNames(qtestType);
        if(paramNames.size() == 0) {

                return true;
        }
        paramNames.push_back("error");
        paramNames.push_back("warning");
        
        std::map<std::string, std::string> namesMap=testsRequested[qtestName];
        
        for(std::vector<std::string>::iterator namesItr=paramNames.begin(); namesItr!=paramNames.end(); ++namesItr){
                if(namesMap.find(*namesItr)==namesMap.end()){
                        return true;
                }
        }

        return false;
}

bool QTestConfigurationParser::monitorElementTestsMap(){
        
        std::string testON="true";
        std::string testOFF="false";
        
        unsigned int linkTagsNum  = 
          doc()->getElementsByTagName(qtxml::_toDOMS("LINK"))->getLength();


        for (unsigned int i=0; i<linkTagsNum; ++i){
        
                DOMNode* linkNode = 
                  doc()->getElementsByTagName(qtxml::_toDOMS("LINK"))->item(i);
                if (! linkNode){
                        return true;
                }
                DOMElement* linkElement = static_cast<DOMElement *>(linkNode);          
                if (! linkElement){
                        return true;             
                }
                std::string linkName = qtxml::_toString (linkElement->getAttribute (qtxml::_toDOMS ("name"))); 
        
                DOMNodeList *testList = linkElement->getElementsByTagName (qtxml::_toDOMS ("TestName"));
                unsigned int numberOfTests=testList->getLength();
                
                std::vector<std::string> qualityTestList;
                for(unsigned int tt=0; tt<numberOfTests; ++tt){
                        DOMElement * testElement = dynamic_cast <DOMElement *> ( testList ->item(tt));          
                        if (!testElement ){
                                return true;             
                        }
                
                        std::string activate = qtxml::_toString (testElement ->getAttribute (qtxml::_toDOMS ("activate"))); 
                                
                                DOMText *argText = dynamic_cast <DOMText *> (testElement ->getFirstChild());
           
                                if(!std::strcmp(activate.c_str(),testON.c_str()))  {                            
                                        if (!argText){
                                                return true;
                                        }else{
                                                std::string regExpValue = qtxml::_toString (argText->getData());
                                                qualityTestList.push_back(regExpValue);         
                                        }               
                                }                               
                                if(!std::strcmp(activate.c_str(),testOFF.c_str())) {
                                        if (argText) {
                                                std::string regExpValue = qtxml::_toString (argText->getData());                                                
                                                // Create List of QTests to unattach from current ME
                                        }                               
                                }
                        
                }
        
        
                if(qualityTestList.size()) mapMonitorElementTests[linkName]=qualityTestList;
        }

        
        return false;



}