#include <XmlConfigParser.h>

Public Member Functions
void	buildGlobalDoc (const std::string &key, const std::string &topPath="")

xercesc::DOMElement *	getKeyElement (const std::string &key)

void	readContext (const xercesc::DOMElement *element, const std::string &sysId, TriggerSystem &aTriggerSystem)

void	readContexts (const std::string &key, const std::string &sysId, TriggerSystem &aTriggerSystem)

void	readDOMFromFile (const std::string &fName)

void	readDOMFromFile (const std::string &fName, xercesc::DOMDocument *&doc)

void	readDOMFromString (const std::string &str)

void	readDOMFromString (const std::string &str, xercesc::DOMDocument *&doc)

void	readElement (const xercesc::DOMElement *element, TriggerSystem &aTriggerSystem, const std::string &sysId="")

void	readHwDescription (const xercesc::DOMElement *element, TriggerSystem &aTriggerSystem, const std::string &sysId="")

void	readRootElement (TriggerSystem &aTriggerSystem, const std::string &sysId="")

	XmlConfigParser ()

	XmlConfigParser (xercesc::DOMDocument *doc)

	~XmlConfigParser ()

Public Attributes
const XMLCh *	kAttrDelim

const XMLCh *	kAttrId

const XMLCh *	kAttrModule

const XMLCh *	kAttrType

const XMLCh *	kTagAlgo

const XMLCh *	kTagColumns

const XMLCh *	kTagContext

const XMLCh *	kTagCrate

const XMLCh *	kTagDaqTtc

const XMLCh *	kTagDb

const XMLCh *	kTagDisable

const XMLCh *	kTagExclBoards

const XMLCh *	kTagExclude

const XMLCh *	kTagHw

const XMLCh *	kTagKey

const XMLCh *	kTagLoad

const XMLCh *	kTagMask

const XMLCh *	kTagParam

const XMLCh *	kTagProcessor

const XMLCh *	kTagRole

const XMLCh *	kTagRow

const XMLCh *	kTagRunSettings

const XMLCh *	kTagSlot

const XMLCh *	kTagTypes

const std::string	kTypeTable

Private Member Functions
void	appendNodesFromSubDoc (xercesc::DOMNode parentNode, xercesc::DOMDocument subDoc)

char *	pruneString (char *&str)

void	pruneString (std::string &str)

Private Attributes
xercesc::DOMDocument *	doc_

xercesc::XercesDOMParser *	parser_

Detailed Description

Definition at line 23 of file XmlConfigParser.h.

Constructor & Destructor Documentation

◆ XmlConfigParser() [1/2]

XmlConfigParser::XmlConfigParser ( )

Initialise XML parser

Definition at line 30 of file XmlConfigParser.cc.

     : kTagHw(nullptr),
       kTagAlgo(nullptr),
       kTagRunSettings(nullptr),
       kTagDb(nullptr),
       kTagKey(nullptr),
       kTagLoad(nullptr),
       kTagContext(nullptr),
       kTagParam(nullptr),
       kTagMask(nullptr),
       kTagDisable(nullptr),
       kTagExclBoards(nullptr),
       kTagExclude(nullptr),
       kTagColumns(nullptr),
       kTagTypes(nullptr),
       kTagRow(nullptr),
       kTagProcessor(nullptr),
       kTagRole(nullptr),
       kTagCrate(nullptr),
       kTagSlot(nullptr),
       kTagDaqTtc(nullptr),
       kAttrId(nullptr),
       kAttrType(nullptr),
       kAttrDelim(nullptr),
       kAttrModule(nullptr),
       kTypeTable("table") {
   XMLPlatformUtils::Initialize();
  
   kTagHw = XMLString::transcode("system");
   kTagAlgo = XMLString::transcode("algo");
   kTagRunSettings = XMLString::transcode("run-settings");
   kTagDb = XMLString::transcode("db");
   kTagKey = XMLString::transcode("key");
   kTagLoad = XMLString::transcode("load");
   kTagContext = XMLString::transcode("context");
   kTagParam = XMLString::transcode("param");
   kTagMask = XMLString::transcode("mask");
   kTagDisable = XMLString::transcode("disable");
   kTagExclBoards = XMLString::transcode("excluded-boards");
   kTagExclude = XMLString::transcode("exclude");
   kTagColumns = XMLString::transcode("columns");
   kTagTypes = XMLString::transcode("types");
   kTagRow = XMLString::transcode("row");
   kTagProcessor = XMLString::transcode("processor");
   kTagRole = XMLString::transcode("role");
   kTagCrate = XMLString::transcode("crate");
   kTagSlot = XMLString::transcode("slot");
   kTagDaqTtc = XMLString::transcode("daqttc-mgr");
   kAttrId = XMLString::transcode("id");
   kAttrType = XMLString::transcode("type");
   kAttrDelim = XMLString::transcode("delimiter");
   kAttrModule = XMLString::transcode("module");
  
   parser_ = new XercesDOMParser();
   parser_->setValidationScheme(XercesDOMParser::Val_Auto);
   parser_->setDoNamespaces(false);
  
   doc_ = nullptr;
 }

References doc_, kAttrDelim, kAttrId, kAttrModule, kAttrType, kTagAlgo, kTagColumns, kTagContext, kTagCrate, kTagDaqTtc, kTagDb, kTagDisable, kTagExclBoards, kTagExclude, kTagHw, kTagKey, kTagLoad, kTagMask, kTagParam, kTagProcessor, kTagRole, kTagRow, kTagRunSettings, kTagSlot, kTagTypes, and parser_.

◆ XmlConfigParser() [2/2]

l1t::XmlConfigParser::XmlConfigParser ( xercesc::DOMDocument * doc )

◆ ~XmlConfigParser()

XmlConfigParser::~XmlConfigParser ( )

Definition at line 148 of file XmlConfigParser.cc.

                                   {
   delete parser_;
   XMLPlatformUtils::Terminate();
 }

References parser_.

Member Function Documentation

◆ appendNodesFromSubDoc()

void XmlConfigParser::appendNodesFromSubDoc	(	xercesc::DOMNode *	parentNode,
		xercesc::DOMDocument *	subDoc
	)

private

Definition at line 560 of file XmlConfigParser.cc.

                                                                                     {
   DOMElement* subDocRootElement = subDoc->getDocumentElement();
   //std::cout << "root element tag: " << cms::xerces::toString(subDocRootElement->getTagName()) << std::endl;
   if (XMLString::equals(subDocRootElement->getTagName(), kTagAlgo) ||
       XMLString::equals(subDocRootElement->getTagName(), kTagRunSettings)) {
     DOMNode* importedNode = doc_->importNode(subDocRootElement, true);
     parentNode->appendChild(importedNode);
   }
 }

References doc_, equals(), kTagAlgo, and kTagRunSettings.

Referenced by buildGlobalDoc().

◆ buildGlobalDoc()

void XmlConfigParser::buildGlobalDoc	(	const std::string &	key,
		const std::string &	topPath = `""`
	)

Definition at line 533 of file XmlConfigParser.cc.

                                                                                    {
   DOMElement* keyElement = getKeyElement(key);
   if (keyElement) {
     DOMNodeList* loadElements = keyElement->getElementsByTagName(kTagLoad);
     for (XMLSize_t i = 0; i < loadElements->getLength(); ++i) {
       DOMElement* loadElement = static_cast<DOMElement*>(loadElements->item(i));
       std::string fileName = cms::xerces::toString(loadElement->getAttribute(kAttrModule));
       if (fileName.find("/") != 0) {  // load element has a relative path
         // build an absolute path with directory of top xml file
         size_t pos;
         std::string topDir = "";
         pos = topPath.find_last_of("/");
         if (pos != std::string::npos) {
           topDir = topPath.substr(0, pos + 1);
         }
         fileName = topDir + fileName;
       }
       //std::cout << "loading file " << fileName << std::endl;
       DOMDocument* subDoc = nullptr;
       readDOMFromFile(fileName, subDoc);
       if (subDoc) {
         appendNodesFromSubDoc(keyElement, subDoc);
       }
     }
   }
 }

References appendNodesFromSubDoc(), MillePedeFileConverter_cfg::fileName, getKeyElement(), mps_fire::i, kAttrModule, crabWrapper::key, kTagLoad, readDOMFromFile(), AlCaHLTBitMon_QueryRunRegistry::string, and cms::xerces::toString().

Referenced by l1t::TriggerSystem::configureSystemFromFiles().

◆ getKeyElement()

DOMElement * XmlConfigParser::getKeyElement ( const std::string & key )

Definition at line 518 of file XmlConfigParser.cc.

                                                                {
   DOMElement* rootElement = doc_->getDocumentElement();
   if (XMLString::equals(rootElement->getTagName(), kTagDb)) {
     DOMNodeList* keyElements = rootElement->getElementsByTagName(kTagKey);
  
     for (XMLSize_t i = 0; i < keyElements->getLength(); ++i) {
       DOMElement* keyElement = static_cast<DOMElement*>(keyElements->item(i));
       if (cms::xerces::toString(keyElement->getAttribute(kAttrId)) == key) {  // we found the key we were looking for
         return keyElement;
       }
     }
   }
   return nullptr;
 }

References doc_, equals(), mps_fire::i, kAttrId, crabWrapper::key, kTagDb, kTagKey, and cms::xerces::toString().

Referenced by buildGlobalDoc(), and readContexts().

◆ pruneString() [1/2]

char * XmlConfigParser::pruneString ( char *& str )

private

Definition at line 582 of file XmlConfigParser.cc.

                                              {
   size_t alphanumBegin = 0, alphanumEnd = strlen(str) - 1;
  
   while (str[alphanumBegin] && XmlConfigParser_reject_symbols[unsigned(str[alphanumBegin])])
     alphanumBegin++;
   while (alphanumEnd >= alphanumBegin && XmlConfigParser_reject_symbols[unsigned(str[alphanumEnd])])
     alphanumEnd--;
  
   str[alphanumEnd + 1] = '\0';
   return str + alphanumBegin;
 }

References str, and XmlConfigParser_reject_symbols.

◆ pruneString() [2/2]

void XmlConfigParser::pruneString ( std::string & str )

private

Definition at line 594 of file XmlConfigParser.cc.

                                                 {
   std::size_t alphanumBegin = str.find_first_not_of("\n\t ");
   std::size_t alphanumEnd = str.find_last_not_of("\n\t ");
   if (alphanumBegin != std::string::npos) {
     if (alphanumEnd != std::string::npos) {
       str = str.substr(alphanumBegin, alphanumEnd - alphanumBegin + 1);
     } else {
       str = str.substr(alphanumBegin);
     }
   }
 }

References str.

Referenced by readContext(), and readHwDescription().

◆ readContext()

void XmlConfigParser::readContext	(	const xercesc::DOMElement *	element,
		const std::string &	sysId,
		TriggerSystem &	aTriggerSystem
	)

columnsStr = cms::xerces::toString(colChilds->item(k)->getNodeValue()); pruneString(columnsStr);

typesStr = cms::xerces::toString(colTypesChilds->item(k)->getNodeValue()); pruneString(typesStr);

std::string rowStr = cms::xerces::toString(rowChilds->item(k)->getNodeValue()); pruneString(rowStr); rowStrs.push_back(rowStr);

Definition at line 376 of file XmlConfigParser.cc.

                                                                                                                   {
   std::string systemId = sysId;
   if (systemId.empty()) {
     systemId = aTriggerSystem.systemId();
   }
   if (cms::xerces::toString(element->getAttribute(kAttrId)) == systemId) {
     DOMNodeList* contextElements = element->getElementsByTagName(kTagContext);
  
     for (XMLSize_t i = 0; i < contextElements->getLength(); ++i) {
       DOMElement* contextElement = static_cast<DOMElement*>(contextElements->item(i));
       std::string contextId = cms::xerces::toString(contextElement->getAttribute(kAttrId));
       pruneString(contextId);
  
       for (DOMElement* elem = static_cast<DOMElement*>(contextElement->getFirstChild()); elem;
            elem = static_cast<DOMElement*>(elem->getNextSibling())) {
         if (elem->getNodeType() == DOMNode::ELEMENT_NODE) {
           if (XMLString::equals(elem->getTagName(), kTagParam)) {
             // found a parameter
             string id = cms::xerces::toString(elem->getAttribute(kAttrId));
             string type = cms::xerces::toString(elem->getAttribute(kAttrType));
             string delim = cms::xerces::toString(elem->getAttribute(kAttrDelim));
             pruneString(id);
             pruneString(type);
             pruneString(delim);
  
             // the type table needs special treatment since it consists of child nodes
             if (type == kTypeTable) {
               // get the columns string
               std::string columnsStr = "";
               DOMNodeList* colElements = elem->getElementsByTagName(kTagColumns);
               for (XMLSize_t j = 0; j < colElements->getLength(); ++j) {
                 DOMNodeList* colChilds = colElements->item(j)->getChildNodes();
                 for (XMLSize_t k = 0; k < colChilds->getLength(); ++k) {
                   if (colChilds->item(k)->getNodeType() == DOMNode::TEXT_NODE) {
                     char* cStr = xercesc::XMLString::transcode(colChilds->item(k)->getNodeValue());
                     char *saveptr, first = 1;
                     for (char* item = strtok_r(cStr, delim.c_str(), &saveptr); item != nullptr;
                          item = strtok_r(nullptr, delim.c_str(), &saveptr), first = 0)
                       columnsStr += (first ? std::string("") : delim) + pruneString(item);
                     xercesc::XMLString::release(&cStr);
                   }
                 }
               }
  
               // get the column type string
               std::string typesStr = "";
               DOMNodeList* colTypesElements = elem->getElementsByTagName(kTagTypes);
               for (XMLSize_t j = 0; j < colTypesElements->getLength(); ++j) {
                 DOMNodeList* colTypesChilds = colTypesElements->item(j)->getChildNodes();
                 for (XMLSize_t k = 0; k < colTypesChilds->getLength(); ++k) {
                   if (colTypesChilds->item(k)->getNodeType() == DOMNode::TEXT_NODE) {
                     char* tStr = xercesc::XMLString::transcode(colTypesChilds->item(k)->getNodeValue());
                     char *saveptr, first = 1;
                     for (char* item = strtok_r(tStr, delim.c_str(), &saveptr); item != nullptr;
                          item = strtok_r(nullptr, delim.c_str(), &saveptr), first = 0)
                       typesStr += (first ? std::string("") : delim) + pruneString(item);
                     xercesc::XMLString::release(&tStr);
                   }
                 }
               }
  
               // get the rows
               std::vector<std::string> rowStrs;
               DOMNodeList* rowElements = elem->getElementsByTagName(kTagRow);
               for (XMLSize_t j = 0; j < rowElements->getLength(); ++j) {
                 DOMNodeList* rowChilds = rowElements->item(j)->getChildNodes();
                 for (XMLSize_t k = 0; k < rowChilds->getLength(); ++k) {
                   if (rowChilds->item(k)->getNodeType() == DOMNode::TEXT_NODE) {
                     char* rStr = xercesc::XMLString::transcode(rowChilds->item(k)->getNodeValue());
                     char *saveptr, first = 1;
                     std::string row;
                     for (char* item = strtok_r(rStr, delim.c_str(), &saveptr); item != nullptr;
                          item = strtok_r(nullptr, delim.c_str(), &saveptr), first = 0)
                       row += (first ? std::string("") : delim) + pruneString(item);
  
                     rowStrs.push_back(row);
                     xercesc::XMLString::release(&rStr);
                   }
                 }
               }
               //         std::cout << "param element node with id attribute " << id << " and type attribute " << typesStr << std::endl;
               aTriggerSystem.addTable(
                   id.c_str(), contextId.c_str(), columnsStr.c_str(), typesStr.c_str(), rowStrs, delim.c_str());
  
             } else {  // all types other than table
               std::string value = "";
               DOMNodeList* valNodes = elem->getChildNodes();
               for (XMLSize_t j = 0; j < valNodes->getLength(); ++j) {
                 if (valNodes->item(j)->getNodeType() == DOMNode::TEXT_NODE) {
                   value += cms::xerces::toString(valNodes->item(j)->getNodeValue());  // should we prune?
                 }
               }
  
               // strip leading and trailing line breaks and spaces
               pruneString(value);
  
               //              std::cout << "param element node with id attribute " << id << " and type attribute " << type << " with value: [" << value << "]" << std::endl;
               aTriggerSystem.addParameter(id.c_str(), contextId.c_str(), type.c_str(), value.c_str(), delim.c_str());
             }
  
           } else if (XMLString::equals(elem->getTagName(), kTagMask)) {
             // found a Mask
             std::string id = cms::xerces::toString(elem->getAttribute(kAttrId));
             //std::cout << "Mask element node with id attribute " << id << std::endl;
             pruneString(id);
             aTriggerSystem.addMask(id.c_str(), contextId.c_str());
  
           } else if (XMLString::equals(elem->getTagName(), kTagDisable)) {
             // found a disable
             std::string id = cms::xerces::toString(elem->getAttribute(kAttrId));
             pruneString(id);
             aTriggerSystem.disableProcOrRoleOrDaq(id.c_str());
           }
         }
       }
     }
   }
 }

References l1t::TriggerSystem::addMask(), l1t::TriggerSystem::addParameter(), l1t::TriggerSystem::addTable(), cms::xerces::cStr(), l1t::TriggerSystem::disableProcOrRoleOrDaq(), equals(), dqmdumpme::first, mps_fire::i, B2GTnPMonitor_cfi::item, dqmiolumiharvest::j, dqmdumpme::k, kAttrDelim, kAttrId, kAttrType, kTagColumns, kTagContext, kTagDisable, kTagMask, kTagParam, kTagRow, kTagTypes, kTypeTable, pruneString(), fetchall_from_DQM_v2::release, AlCaHLTBitMon_QueryRunRegistry::string, l1t::TriggerSystem::systemId(), and cms::xerces::toString().

Referenced by readContexts(), and readElement().

◆ readContexts()

void XmlConfigParser::readContexts	(	const std::string &	key,
		const std::string &	sysId,
		TriggerSystem &	aTriggerSystem
	)

Definition at line 502 of file XmlConfigParser.cc.

                                                                                                               {
   DOMElement* keyElement = getKeyElement(key);
   if (keyElement) {
     for (DOMElement* elem = static_cast<DOMElement*>(keyElement->getFirstChild()); elem;
          elem = static_cast<DOMElement*>(elem->getNextSibling())) {
       if (elem->getNodeType() == DOMNode::ELEMENT_NODE) {
         if (XMLString::equals(elem->getTagName(), kTagAlgo) || XMLString::equals(elem->getTagName(), kTagRunSettings)) {
           readContext(elem, sysId, aTriggerSystem);
         }
       }
     }
   } else {
     throw std::runtime_error("Key not found: " + key);
   }
 }

References equals(), getKeyElement(), crabWrapper::key, kTagAlgo, kTagRunSettings, and readContext().

Referenced by l1t::TriggerSystem::configureSystemFromFiles().

◆ readDOMFromFile() [1/2]

void XmlConfigParser::readDOMFromFile ( const std::string & fName )

Definition at line 178 of file XmlConfigParser.cc.

                                                             {
   parser_->parse(fName.c_str());
   doc_ = parser_->getDocument();
  
   if (!doc_) {
     edm::LogError("XmlConfigParser") << "Could not parse file " << fName << "\n";
   }
  
   assert(doc_);
 }

References cms::cuda::assert(), doc_, MainPageGenerator::fName, and parser_.

◆ readDOMFromFile() [2/2]

void l1t::XmlConfigParser::readDOMFromFile	(	const std::string &	fName,
		xercesc::DOMDocument *&	doc
	)

Referenced by buildGlobalDoc(), and l1t::TriggerSystem::configureSystemFromFiles().

◆ readDOMFromString() [1/2]

void XmlConfigParser::readDOMFromString ( const std::string & str )

Definition at line 160 of file XmlConfigParser.cc.

                                                             {
   MemBufInputSource xmlstr_buf((const XMLByte*)(str.c_str()), str.size(), "xmlstrbuf");
   parser_->parse(xmlstr_buf);
   doc_ = parser_->getDocument();
   assert(doc_);
 }

References cms::cuda::assert(), doc_, parser_, and str.

◆ readDOMFromString() [2/2]

void l1t::XmlConfigParser::readDOMFromString	(	const std::string &	str,
		xercesc::DOMDocument *&	doc
	)

Referenced by L1TMuonEndCapObjectKeysOnlineProd::fillObjectKeys(), L1TGlobalPrescalesVetosESProducer::L1TGlobalPrescalesVetosESProducer(), L1TMuonGlobalParamsOnlineProd::newObject(), L1TMuonEndCapParamsOnlineProd::newObject(), L1TMuonBarrelParamsOnlineProd::newObject(), L1TGlobalPrescalesVetosOnlineProd::newObject(), and L1TCaloParamsOnlineProd::newObject().

◆ readElement()

void XmlConfigParser::readElement	(	const xercesc::DOMElement *	element,
		TriggerSystem &	aTriggerSystem,
		const std::string &	sysId = `""`
	)

Definition at line 200 of file XmlConfigParser.cc.

                                                                                                                   {
   if (XMLString::equals(element->getTagName(), kTagHw)) {
     // in case this is a HW description
     readHwDescription(element, aTriggerSystem, sysId);
   } else if (XMLString::equals(element->getTagName(), kTagAlgo) ||
              XMLString::equals(element->getTagName(), kTagRunSettings)) {
     // in case this is a configuration snippet
     readContext(element, sysId, aTriggerSystem);
   }
 }

References equals(), kTagAlgo, kTagHw, kTagRunSettings, readContext(), and readHwDescription().

Referenced by readRootElement().

◆ readHwDescription()

void XmlConfigParser::readHwDescription	(	const xercesc::DOMElement *	element,
		TriggerSystem &	aTriggerSystem,
		const std::string &	sysId = `""`
	)

Definition at line 211 of file XmlConfigParser.cc.

                                                                 {
   // if sysId == "" set the systemId of the trigsystem from the xml sytem id
   if (!sysId.empty()) {
     std::string sId = cms::xerces::toString(element->getAttribute(kAttrId));
     pruneString(sId);
     if (sId != sysId)
       return;
   }
  
   char* sysId_ = xercesc::XMLString::transcode(element->getAttribute(kAttrId));
   aTriggerSystem.setSystemId(pruneString(sysId_));
   xercesc::XMLString::release(&sysId_);
  
   // handle processors
   DOMNodeList* processors = element->getElementsByTagName(kTagProcessor);
   XMLSize_t nodeCount = processors->getLength();
   for (XMLSize_t xx = 0; xx < nodeCount; ++xx) {
     DOMNode* currentNode = processors->item(xx);
     if (currentNode->getNodeType() && currentNode->getNodeType() == DOMNode::ELEMENT_NODE) {  //no null and is element
       DOMElement* currentElement = static_cast<DOMElement*>(currentNode);
  
       string proc = cms::xerces::toString(currentElement->getAttribute(kAttrId));
       pruneString(proc);
       string role, crate, slot;
  
       DOMNodeList* roles = currentElement->getElementsByTagName(kTagRole);
       // roles of this processor (should be only one)
       if (roles->getLength() != 1)
         throw std::runtime_error(string("Configutration specify not exactly one role"));
       //      for (XMLSize_t i = 0; i < roles->getLength(); ++i) {
       {
         XMLSize_t i = 0;
         DOMNodeList* roleChilds = roles->item(i)->getChildNodes();
         if (roleChilds->getLength() != 1)
           throw std::runtime_error(string("Configutration specify not exactly one role"));
         {
           //        for (XMLSize_t j = 0; j < roleChilds->getLength(); ++j) {
           XMLSize_t j = 0;
           if (roleChilds->item(j)->getNodeType() == DOMNode::TEXT_NODE) {
             role = cms::xerces::toString(roleChilds->item(j)->getNodeValue());
             pruneString(role);
           }
         }
       }
  
       DOMNodeList* crates = currentElement->getElementsByTagName(kTagCrate);
       // crates of this processor (should be only one)
       if (crates->getLength() != 1)
         throw std::runtime_error(string("Configutration specify not exactly one crate"));
       //      for (XMLSize_t i = 0; i < crates->getLength(); ++i) {
       {
         XMLSize_t i = 0;
         DOMNodeList* crateChilds = crates->item(i)->getChildNodes();
         if (crateChilds->getLength() != 1)
           throw std::runtime_error(string("Configutration specify not exactly one crate"));
         {
           XMLSize_t j = 0;
           //        for (XMLSize_t j = 0; j < crateChilds->getLength(); ++j) {
           if (crateChilds->item(j)->getNodeType() == DOMNode::TEXT_NODE) {
             crate = cms::xerces::toString(crateChilds->item(j)->getNodeValue());
             pruneString(crate);
           }
         }
       }
  
       DOMNodeList* slots = currentElement->getElementsByTagName(kTagSlot);
       // slots of this processor (should be only one)
       if (slots->getLength() != 1)
         throw std::runtime_error(string("Configutration specify not exactly one slot"));
       //      for (XMLSize_t i = 0; i < slots->getLength(); ++i) {
       {
         XMLSize_t i = 0;
         DOMNodeList* slotChilds = slots->item(i)->getChildNodes();
         if (slotChilds->getLength() != 1)
           throw std::runtime_error(string("Configutration specify not exactly one slot"));
         //        for (XMLSize_t j = 0; j < slotChilds->getLength(); ++j) {
         {
           XMLSize_t j = 0;
           if (slotChilds->item(j)->getNodeType() == DOMNode::TEXT_NODE) {
             slot = cms::xerces::toString(slotChilds->item(j)->getNodeValue());
             pruneString(slot);
           }
         }
       }
  
       aTriggerSystem.addProcessor(proc.c_str(), role.c_str(), crate.c_str(), slot.c_str());
     }
   }
  
   // handle DAQ TTC managers
   DOMNodeList* daqttcs = element->getElementsByTagName(kTagDaqTtc);
   nodeCount = daqttcs->getLength();
   for (XMLSize_t xx = 0; xx < nodeCount; ++xx) {
     DOMNode* currentNode = daqttcs->item(xx);
     if (currentNode->getNodeType() && currentNode->getNodeType() == DOMNode::ELEMENT_NODE) {  //no null and is element
       DOMElement* currentElement = static_cast<DOMElement*>(currentNode);
       string daqttc = cms::xerces::toString(currentElement->getAttribute(kAttrId));
       string role, crate;
  
       DOMNodeList* roles = currentElement->getElementsByTagName(kTagRole);
       // roles of this DAQ TTC manager (should be only one)
       if (roles->getLength() != 1)
         throw std::runtime_error(string("Configutration specify not exactly one role"));
       //      for (XMLSize_t i = 0; i < roles->getLength(); ++i) {
       {
         XMLSize_t i = 0;
         DOMNodeList* roleChilds = roles->item(i)->getChildNodes();
         if (roleChilds->getLength() != 1)
           throw std::runtime_error(string("Configutration specify not exactly one role"));
         //        for (XMLSize_t j = 0; j < roleChilds->getLength(); ++j) {
         {
           XMLSize_t j = 0;
           if (roleChilds->item(j)->getNodeType() == DOMNode::TEXT_NODE) {
             role = cms::xerces::toString(roleChilds->item(j)->getNodeValue());
             pruneString(role);
           }
         }
       }
  
       DOMNodeList* crates = currentElement->getElementsByTagName(kTagCrate);
       // crates of this DAQ TTC manager (should be only one)
       if (crates->getLength() != 1)
         throw std::runtime_error(string("Configutration specify not exactly one crate"));
       //      for (XMLSize_t i = 0; i < crates->getLength(); ++i) {
       {
         XMLSize_t i = 0;
         DOMNodeList* crateChilds = crates->item(i)->getChildNodes();
         if (crateChilds->getLength() != 1)
           throw std::runtime_error(string("Configutration specify not exactly one crate"));
         //        for (XMLSize_t j = 0; j < crateChilds->getLength(); ++j) {
         {
           XMLSize_t j = 0;
           if (crateChilds->item(j)->getNodeType() == DOMNode::TEXT_NODE) {
             crate = cms::xerces::toString(crateChilds->item(j)->getNodeValue());
             pruneString(crate);
           }
         }
       }
  
       aTriggerSystem.addDaq(daqttc.c_str(), role.c_str(), crate.c_str());
     }
   }
  
   // handle excluded boards
   DOMNodeList* exclBoards = element->getElementsByTagName(kTagExclBoards);
   for (XMLSize_t xx = 0; xx < exclBoards->getLength(); ++xx) {
     DOMElement* exclBoardElem = static_cast<DOMElement*>(exclBoards->item(xx));
  
     for (DOMElement* elem = static_cast<DOMElement*>(exclBoardElem->getFirstChild()); elem;
          elem = static_cast<DOMElement*>(elem->getNextSibling())) {
       if (elem->getNodeType() == DOMNode::ELEMENT_NODE) {
         if (XMLString::equals(elem->getTagName(), kTagExclude)) {
           // found an excluded board
           std::string id = cms::xerces::toString(elem->getAttribute(kAttrId));
           pruneString(id);
           aTriggerSystem.disableProcOrRoleOrDaq(
               id.c_str());  // handle in the same way as disabled ids in the run-settings
         }
       }
     }
   }
 }

References l1t::TriggerSystem::addDaq(), l1t::TriggerSystem::addProcessor(), l1t::TriggerSystem::disableProcOrRoleOrDaq(), equals(), mps_fire::i, dqmiolumiharvest::j, kAttrId, kTagCrate, kTagDaqTtc, kTagExclBoards, kTagExclude, kTagProcessor, kTagRole, kTagSlot, ValidateTausOnZEEFastSim_cff::proc, pruneString(), fetchall_from_DQM_v2::release, l1t::TriggerSystem::setSystemId(), AlCaHLTBitMon_QueryRunRegistry::string, cms::xerces::toString(), and geometryCSVtoXML::xx.

Referenced by readElement().

◆ readRootElement()

void XmlConfigParser::readRootElement	(	TriggerSystem &	aTriggerSystem,
		const std::string &	sysId = `""`
	)

Definition at line 189 of file XmlConfigParser.cc.

                                                                                            {
   DOMElement* rootElement = doc_->getDocumentElement();
   if (rootElement) {
     if (rootElement->getNodeType() == DOMNode::ELEMENT_NODE) {
       readElement(rootElement, aTriggerSystem, sysId);
     }
   } else {
     throw std::runtime_error("No xml root element found");
   }
 }