#include <QTestConfigurationParser.h>

Inheritance diagram for QTestConfigurationParser:

Public Member Functions
std::map< std::string, std::vector< std::string > >	meToTestsList () const
	Returns the map between the MonitoElemnt and the list of tests requested for it. More...

bool	parseQTestsConfiguration ()
	Methor that parses the xml file configFile, returns false if no errors are encountered. More...

	QTestConfigurationParser ()
	Creator. More...

std::map< std::string, std::map< std::string, std::string > >	testsList () const
	Returns the Quality Tests list with their parameters obtained from the xml file. More...

	~QTestConfigurationParser ()
	Destructor. More...

Public Member Functions inherited from DQMParserBase
int	countNodes (std::string tagName)
	Returns the number of nodes with given name. More...

xercesc::DOMDocument *	doc ()
	DOM Document. More...

	DQMParserBase ()
	Creator. More...

void	getDocument (std::string configFile, bool UseDB=false)
	Methor that parses the xml file configFile. More...

void	getNewDocument (std::string configFile, bool UseDB=false)
	Parses a new Document. More...

virtual	~DQMParserBase ()
	Destructor. More...

Private Member Functions
bool	checkParameters (std::string qtestName, std::string qtestType)

std::map< std::string, std::string >	getParams (xercesc::DOMElement *qtestElement, std::string test)

int	instances ()

bool	monitorElementTestsMap ()

bool	qtestsConfig ()

Private Attributes
std::map< std::string, std::vector< std::string > >	mapMonitorElementTests

QTestParameterNames *	qtestParamNames

std::map< std::string, std::map< std::string, std::string > >	testsRequested

std::vector< std::string >	testsToDisable

Static Private Attributes
static int	s_numberOfInstances = 0

Additional Inherited Members
Protected Attributes inherited from DQMParserBase
xercesc::XercesDOMParser *	parser

Detailed Description

Parses the xml file with the configuration of quality tests and the map between quality tests and MonitorElement

Author
Ilaria Segoni

Definition at line 22 of file QTestConfigurationParser.h.

Constructor & Destructor Documentation

QTestConfigurationParser::QTestConfigurationParser ( )

Creator.

Definition at line 17 of file QTestConfigurationParser.cc.

References alignCSCRings::e, and cms::concurrency::xercesInitialize().

                                                   {
         
     qtestParamNames=new QTestParameterNames();
 
     try { 
         if (s_numberOfInstances==0) 
         cms::concurrency::xercesInitialize();  
     }
     catch (const XMLException& e) {
         throw(std::runtime_error("Standard pool exception : Fatal Error on pool::TrivialFileCatalog"));
     }
  
     ++s_numberOfInstances;
 }

QTestConfigurationParser::~QTestConfigurationParser ( )

Destructor.

Definition at line 32 of file QTestConfigurationParser.cc.

                                                    {
     delete qtestParamNames;
     qtestParamNames = 0;
 }

Member Function Documentation

bool QTestConfigurationParser::checkParameters	(	std::string	qtestName,
		std::string	qtestType
	)

private

Definition at line 123 of file QTestConfigurationParser.cc.

                                                                                       {
     
     std::vector<std::string> paramNames=qtestParamNames->getTestParamNames(qtestType);
         // commenting out as does not seem to be logical SDutta 22/3/2013 
     /*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;
 }

std::map< std::string, std::string > QTestConfigurationParser::getParams	(	xercesc::DOMElement *	qtestElement,
		std::string	test
	)

private

Definition at line 100 of file QTestConfigurationParser.cc.

References qtxml::_toDOMS(), qtxml::_toString(), i, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                              {
     
     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;
 
 }

int QTestConfigurationParser::instances ( )

inlineprivate

Definition at line 40 of file QTestConfigurationParser.h.

References s_numberOfInstances.

40 {return s_numberOfInstances;}

QTestConfigurationParser::s_numberOfInstances

static int s_numberOfInstances

Definition: QTestConfigurationParser.h:46

std::map<std::string, std::vector<std::string> > QTestConfigurationParser::meToTestsList ( ) const

inline

Returns the map between the MonitoElemnt and the list of tests requested for it.

Definition at line 34 of file QTestConfigurationParser.h.

References mapMonitorElementTests.

Referenced by QTestHandle::attachTests().

34 { return mapMonitorElementTests;}

QTestConfigurationParser::mapMonitorElementTests

std::map< std::string, std::vector< std::string > > mapMonitorElementTests

Definition: QTestConfigurationParser.h:49

bool QTestConfigurationParser::monitorElementTestsMap ( )

private

Get ME name

Loop on linkTagsNum

Definition at line 146 of file QTestConfigurationParser.cc.

References qtxml::_toDOMS(), qtxml::_toString(), i, AlCaHLTBitMon_QueryRunRegistry::string, runTheMatrix::testList, and groupFilesInBlocks::tt.

                                                      {
     
     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;
 
 
 
 }

bool QTestConfigurationParser::parseQTestsConfiguration ( )

Methor that parses the xml file configFile, returns false if no errors are encountered.

Definition at line 37 of file QTestConfigurationParser.cc.

Referenced by QTestHandle::configureTests().

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

bool QTestConfigurationParser::qtestsConfig ( )

private

Get Node

Get QTEST name

Get Qtest TYPE

Definition at line 47 of file QTestConfigurationParser.cc.

References qtxml::_toDOMS(), qtxml::_toString(), i, and AlCaHLTBitMon_QueryRunRegistry::string.

                                            {
     
     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;
  
 }