File indexing completed on 2025-05-27 01:56:21
0001 #include <iostream>
0002
0003
0004 using namespace std;
0005
0006 #include "L1Trigger/L1TCommon/interface/XmlConfigParser.h"
0007 #include "L1Trigger/L1TCommon/interface/TriggerSystem.h"
0008
0009 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0010 #include "Utilities/Xerces/interface/XercesStrUtils.h"
0011 #include "Utilities/Xerces/interface/Xerces.h"
0012
0013 #include "xercesc/util/PlatformUtils.hpp"
0014
0015 XERCES_CPP_NAMESPACE_USE
0016
0017 using namespace l1t;
0018
0019
0020
0021
0022
0023
0024
0025
0026
0027
0028
0029
0030
0031 XmlConfigParser::XmlConfigParser()
0032 : kTagHw(nullptr),
0033 kTagAlgo(nullptr),
0034 kTagRunSettings(nullptr),
0035 kTagDb(nullptr),
0036 kTagKey(nullptr),
0037 kTagLoad(nullptr),
0038 kTagContext(nullptr),
0039 kTagParam(nullptr),
0040 kTagMask(nullptr),
0041 kTagDisable(nullptr),
0042 kTagExclBoards(nullptr),
0043 kTagExclude(nullptr),
0044 kTagColumns(nullptr),
0045 kTagTypes(nullptr),
0046 kTagRow(nullptr),
0047 kTagProcessor(nullptr),
0048 kTagRole(nullptr),
0049 kTagCrate(nullptr),
0050 kTagSlot(nullptr),
0051 kTagDaqTtc(nullptr),
0052 kAttrId(nullptr),
0053 kAttrType(nullptr),
0054 kAttrDelim(nullptr),
0055 kAttrModule(nullptr),
0056 kTypeTable("table") {
0057 cms::concurrency::xercesInitialize();
0058
0059 kTagHw = XMLString::transcode("system");
0060 kTagAlgo = XMLString::transcode("algo");
0061 kTagRunSettings = XMLString::transcode("run-settings");
0062 kTagDb = XMLString::transcode("db");
0063 kTagKey = XMLString::transcode("key");
0064 kTagLoad = XMLString::transcode("load");
0065 kTagContext = XMLString::transcode("context");
0066 kTagParam = XMLString::transcode("param");
0067 kTagMask = XMLString::transcode("mask");
0068 kTagDisable = XMLString::transcode("disable");
0069 kTagExclBoards = XMLString::transcode("excluded-boards");
0070 kTagExclude = XMLString::transcode("exclude");
0071 kTagColumns = XMLString::transcode("columns");
0072 kTagTypes = XMLString::transcode("types");
0073 kTagRow = XMLString::transcode("row");
0074 kTagProcessor = XMLString::transcode("processor");
0075 kTagRole = XMLString::transcode("role");
0076 kTagCrate = XMLString::transcode("crate");
0077 kTagSlot = XMLString::transcode("slot");
0078 kTagDaqTtc = XMLString::transcode("daqttc-mgr");
0079 kAttrId = XMLString::transcode("id");
0080 kAttrType = XMLString::transcode("type");
0081 kAttrDelim = XMLString::transcode("delimiter");
0082 kAttrModule = XMLString::transcode("module");
0083
0084
0085 parser_ = new XercesDOMParser();
0086 parser_->setValidationScheme(XercesDOMParser::Val_Auto);
0087 parser_->setDoNamespaces(false);
0088
0089 doc_ = nullptr;
0090 }
0091
0092 XmlConfigParser::XmlConfigParser(DOMDocument* doc)
0093 : kTagHw(nullptr),
0094 kTagAlgo(nullptr),
0095 kTagRunSettings(nullptr),
0096 kTagDb(nullptr),
0097 kTagKey(nullptr),
0098 kTagLoad(nullptr),
0099 kTagContext(nullptr),
0100 kTagParam(nullptr),
0101 kTagMask(nullptr),
0102 kTagDisable(nullptr),
0103 kTagExclBoards(nullptr),
0104 kTagExclude(nullptr),
0105 kTagColumns(nullptr),
0106 kTagTypes(nullptr),
0107 kTagRow(nullptr),
0108 kTagProcessor(nullptr),
0109 kTagRole(nullptr),
0110 kTagCrate(nullptr),
0111 kTagSlot(nullptr),
0112 kTagDaqTtc(nullptr),
0113 kAttrId(nullptr),
0114 kAttrType(nullptr),
0115 kAttrDelim(nullptr),
0116 kAttrModule(nullptr),
0117 kTypeTable("table") {
0118 cms::concurrency::xercesInitialize();
0119
0120 kTagHw = XMLString::transcode("system");
0121 kTagAlgo = XMLString::transcode("algo");
0122 kTagRunSettings = XMLString::transcode("run-settings");
0123 kTagDb = XMLString::transcode("db");
0124 kTagKey = XMLString::transcode("key");
0125 kTagLoad = XMLString::transcode("load");
0126 kTagContext = XMLString::transcode("context");
0127 kTagParam = XMLString::transcode("param");
0128 kTagMask = XMLString::transcode("mask");
0129 kTagDisable = XMLString::transcode("disable");
0130 kTagExclBoards = XMLString::transcode("excluded-boards");
0131 kTagExclude = XMLString::transcode("exclude");
0132 kTagColumns = XMLString::transcode("columns");
0133 kTagTypes = XMLString::transcode("types");
0134 kTagRow = XMLString::transcode("row");
0135 kTagProcessor = XMLString::transcode("processor");
0136 kTagRole = XMLString::transcode("role");
0137 kTagCrate = XMLString::transcode("crate");
0138 kTagSlot = XMLString::transcode("slot");
0139 kTagDaqTtc = XMLString::transcode("daqttc-mgr");
0140 kAttrId = XMLString::transcode("id");
0141 kAttrType = XMLString::transcode("type");
0142 kAttrDelim = XMLString::transcode("delimiter");
0143 kAttrModule = XMLString::transcode("module");
0144
0145 parser_ = nullptr;
0146 doc_ = doc;
0147 }
0148
0149 XmlConfigParser::~XmlConfigParser() {
0150 delete parser_;
0151 cms::concurrency::xercesTerminate();
0152 }
0153
0154 void XmlConfigParser::readDOMFromString(const std::string& str, DOMDocument*& doc) {
0155 MemBufInputSource xmlstr_buf((const XMLByte*)(str.c_str()), str.size(), "xmlstrbuf");
0156 parser_->parse(xmlstr_buf);
0157 doc = parser_->getDocument();
0158 assert(doc);
0159 }
0160
0161 void XmlConfigParser::readDOMFromString(const std::string& str) {
0162 MemBufInputSource xmlstr_buf((const XMLByte*)(str.c_str()), str.size(), "xmlstrbuf");
0163 parser_->parse(xmlstr_buf);
0164 doc_ = parser_->getDocument();
0165 assert(doc_);
0166 }
0167
0168 void XmlConfigParser::readDOMFromFile(const std::string& fName, DOMDocument*& doc) {
0169 parser_->parse(fName.c_str());
0170 doc = parser_->getDocument();
0171
0172 if (!doc) {
0173 edm::LogError("XmlConfigParser") << "Could not parse file " << fName << "\n";
0174 }
0175
0176 assert(doc);
0177 }
0178
0179 void XmlConfigParser::readDOMFromFile(const std::string& fName) {
0180 parser_->parse(fName.c_str());
0181 doc_ = parser_->getDocument();
0182
0183 if (!doc_) {
0184 edm::LogError("XmlConfigParser") << "Could not parse file " << fName << "\n";
0185 }
0186
0187 assert(doc_);
0188 }
0189
0190 void XmlConfigParser::readRootElement(TriggerSystem& aTriggerSystem, const std::string& sysId) {
0191 DOMElement* rootElement = doc_->getDocumentElement();
0192 if (rootElement) {
0193 if (rootElement->getNodeType() == DOMNode::ELEMENT_NODE) {
0194 readElement(rootElement, aTriggerSystem, sysId);
0195 }
0196 } else {
0197 throw std::runtime_error("No xml root element found");
0198 }
0199 }
0200
0201 void XmlConfigParser::readElement(const DOMElement* element, TriggerSystem& aTriggerSystem, const std::string& sysId) {
0202 if (XMLString::equals(element->getTagName(), kTagHw)) {
0203
0204 readHwDescription(element, aTriggerSystem, sysId);
0205 } else if (XMLString::equals(element->getTagName(), kTagAlgo) ||
0206 XMLString::equals(element->getTagName(), kTagRunSettings)) {
0207
0208 readContext(element, sysId, aTriggerSystem);
0209 }
0210 }
0211
0212 void XmlConfigParser::readHwDescription(const DOMElement* element,
0213 TriggerSystem& aTriggerSystem,
0214 const std::string& sysId) {
0215
0216 if (!sysId.empty()) {
0217 std::string sId = cms::xerces::toString(element->getAttribute(kAttrId));
0218 pruneString(sId);
0219 if (sId != sysId)
0220 return;
0221 }
0222
0223 char* sysId_ = xercesc::XMLString::transcode(element->getAttribute(kAttrId));
0224 aTriggerSystem.setSystemId(pruneString(sysId_));
0225 xercesc::XMLString::release(&sysId_);
0226
0227
0228 DOMNodeList* processors = element->getElementsByTagName(kTagProcessor);
0229 XMLSize_t nodeCount = processors->getLength();
0230 for (XMLSize_t xx = 0; xx < nodeCount; ++xx) {
0231 DOMNode* currentNode = processors->item(xx);
0232 if (currentNode->getNodeType() && currentNode->getNodeType() == DOMNode::ELEMENT_NODE) {
0233 DOMElement* currentElement = static_cast<DOMElement*>(currentNode);
0234
0235 string proc = cms::xerces::toString(currentElement->getAttribute(kAttrId));
0236 pruneString(proc);
0237 string role, crate, slot;
0238
0239 DOMNodeList* roles = currentElement->getElementsByTagName(kTagRole);
0240
0241 if (roles->getLength() != 1)
0242 throw std::runtime_error(string("Configutration specify not exactly one role"));
0243
0244 {
0245 XMLSize_t i = 0;
0246 DOMNodeList* roleChilds = roles->item(i)->getChildNodes();
0247 if (roleChilds->getLength() != 1)
0248 throw std::runtime_error(string("Configutration specify not exactly one role"));
0249 {
0250
0251 XMLSize_t j = 0;
0252 if (roleChilds->item(j)->getNodeType() == DOMNode::TEXT_NODE) {
0253 role = cms::xerces::toString(roleChilds->item(j)->getNodeValue());
0254 pruneString(role);
0255 }
0256 }
0257 }
0258
0259 DOMNodeList* crates = currentElement->getElementsByTagName(kTagCrate);
0260
0261 if (crates->getLength() != 1)
0262 throw std::runtime_error(string("Configutration specify not exactly one crate"));
0263
0264 {
0265 XMLSize_t i = 0;
0266 DOMNodeList* crateChilds = crates->item(i)->getChildNodes();
0267 if (crateChilds->getLength() != 1)
0268 throw std::runtime_error(string("Configutration specify not exactly one crate"));
0269 {
0270 XMLSize_t j = 0;
0271
0272 if (crateChilds->item(j)->getNodeType() == DOMNode::TEXT_NODE) {
0273 crate = cms::xerces::toString(crateChilds->item(j)->getNodeValue());
0274 pruneString(crate);
0275 }
0276 }
0277 }
0278
0279 DOMNodeList* slots = currentElement->getElementsByTagName(kTagSlot);
0280
0281 if (slots->getLength() != 1)
0282 throw std::runtime_error(string("Configutration specify not exactly one slot"));
0283
0284 {
0285 XMLSize_t i = 0;
0286 DOMNodeList* slotChilds = slots->item(i)->getChildNodes();
0287 if (slotChilds->getLength() != 1)
0288 throw std::runtime_error(string("Configutration specify not exactly one slot"));
0289
0290 {
0291 XMLSize_t j = 0;
0292 if (slotChilds->item(j)->getNodeType() == DOMNode::TEXT_NODE) {
0293 slot = cms::xerces::toString(slotChilds->item(j)->getNodeValue());
0294 pruneString(slot);
0295 }
0296 }
0297 }
0298
0299 aTriggerSystem.addProcessor(proc.c_str(), role.c_str(), crate.c_str(), slot.c_str());
0300 }
0301 }
0302
0303
0304 DOMNodeList* daqttcs = element->getElementsByTagName(kTagDaqTtc);
0305 nodeCount = daqttcs->getLength();
0306 for (XMLSize_t xx = 0; xx < nodeCount; ++xx) {
0307 DOMNode* currentNode = daqttcs->item(xx);
0308 if (currentNode->getNodeType() && currentNode->getNodeType() == DOMNode::ELEMENT_NODE) {
0309 DOMElement* currentElement = static_cast<DOMElement*>(currentNode);
0310 string daqttc = cms::xerces::toString(currentElement->getAttribute(kAttrId));
0311 string role, crate;
0312
0313 DOMNodeList* roles = currentElement->getElementsByTagName(kTagRole);
0314
0315 if (roles->getLength() != 1)
0316 throw std::runtime_error(string("Configutration specify not exactly one role"));
0317
0318 {
0319 XMLSize_t i = 0;
0320 DOMNodeList* roleChilds = roles->item(i)->getChildNodes();
0321 if (roleChilds->getLength() != 1)
0322 throw std::runtime_error(string("Configutration specify not exactly one role"));
0323
0324 {
0325 XMLSize_t j = 0;
0326 if (roleChilds->item(j)->getNodeType() == DOMNode::TEXT_NODE) {
0327 role = cms::xerces::toString(roleChilds->item(j)->getNodeValue());
0328 pruneString(role);
0329 }
0330 }
0331 }
0332
0333 DOMNodeList* crates = currentElement->getElementsByTagName(kTagCrate);
0334
0335 if (crates->getLength() != 1)
0336 throw std::runtime_error(string("Configutration specify not exactly one crate"));
0337
0338 {
0339 XMLSize_t i = 0;
0340 DOMNodeList* crateChilds = crates->item(i)->getChildNodes();
0341 if (crateChilds->getLength() != 1)
0342 throw std::runtime_error(string("Configutration specify not exactly one crate"));
0343
0344 {
0345 XMLSize_t j = 0;
0346 if (crateChilds->item(j)->getNodeType() == DOMNode::TEXT_NODE) {
0347 crate = cms::xerces::toString(crateChilds->item(j)->getNodeValue());
0348 pruneString(crate);
0349 }
0350 }
0351 }
0352
0353 aTriggerSystem.addDaq(daqttc.c_str(), role.c_str(), crate.c_str());
0354 }
0355 }
0356
0357
0358 DOMNodeList* exclBoards = element->getElementsByTagName(kTagExclBoards);
0359 for (XMLSize_t xx = 0; xx < exclBoards->getLength(); ++xx) {
0360 DOMElement* exclBoardElem = static_cast<DOMElement*>(exclBoards->item(xx));
0361
0362 for (DOMElement* elem = static_cast<DOMElement*>(exclBoardElem->getFirstChild()); elem;
0363 elem = static_cast<DOMElement*>(elem->getNextSibling())) {
0364 if (elem->getNodeType() == DOMNode::ELEMENT_NODE) {
0365 if (XMLString::equals(elem->getTagName(), kTagExclude)) {
0366
0367 std::string id = cms::xerces::toString(elem->getAttribute(kAttrId));
0368 pruneString(id);
0369 aTriggerSystem.disableProcOrRoleOrDaq(
0370 id.c_str());
0371 }
0372 }
0373 }
0374 }
0375 }
0376
0377 void XmlConfigParser::readContext(const DOMElement* element, const std::string& sysId, TriggerSystem& aTriggerSystem) {
0378 std::string systemId = sysId;
0379 if (systemId.empty()) {
0380 systemId = aTriggerSystem.systemId();
0381 }
0382 if (cms::xerces::toString(element->getAttribute(kAttrId)) == systemId) {
0383 DOMNodeList* contextElements = element->getElementsByTagName(kTagContext);
0384
0385 for (XMLSize_t i = 0; i < contextElements->getLength(); ++i) {
0386 DOMElement* contextElement = static_cast<DOMElement*>(contextElements->item(i));
0387 std::string contextId = cms::xerces::toString(contextElement->getAttribute(kAttrId));
0388 pruneString(contextId);
0389
0390 for (DOMElement* elem = static_cast<DOMElement*>(contextElement->getFirstChild()); elem;
0391 elem = static_cast<DOMElement*>(elem->getNextSibling())) {
0392 if (elem->getNodeType() == DOMNode::ELEMENT_NODE) {
0393 if (XMLString::equals(elem->getTagName(), kTagParam)) {
0394
0395 string id = cms::xerces::toString(elem->getAttribute(kAttrId));
0396 string type = cms::xerces::toString(elem->getAttribute(kAttrType));
0397 string delim = cms::xerces::toString(elem->getAttribute(kAttrDelim));
0398 pruneString(id);
0399 pruneString(type);
0400 pruneString(delim);
0401
0402
0403 if (type == kTypeTable) {
0404
0405 std::string columnsStr = "";
0406 DOMNodeList* colElements = elem->getElementsByTagName(kTagColumns);
0407 for (XMLSize_t j = 0; j < colElements->getLength(); ++j) {
0408 DOMNodeList* colChilds = colElements->item(j)->getChildNodes();
0409 for (XMLSize_t k = 0; k < colChilds->getLength(); ++k) {
0410 if (colChilds->item(k)->getNodeType() == DOMNode::TEXT_NODE) {
0411
0412
0413 char* cStr = xercesc::XMLString::transcode(colChilds->item(k)->getNodeValue());
0414 char *saveptr, first = 1;
0415 for (char* item = strtok_r(cStr, delim.c_str(), &saveptr); item != nullptr;
0416 item = strtok_r(nullptr, delim.c_str(), &saveptr), first = 0)
0417 columnsStr += (first ? std::string("") : delim) + pruneString(item);
0418 xercesc::XMLString::release(&cStr);
0419 }
0420 }
0421 }
0422
0423
0424 std::string typesStr = "";
0425 DOMNodeList* colTypesElements = elem->getElementsByTagName(kTagTypes);
0426 for (XMLSize_t j = 0; j < colTypesElements->getLength(); ++j) {
0427 DOMNodeList* colTypesChilds = colTypesElements->item(j)->getChildNodes();
0428 for (XMLSize_t k = 0; k < colTypesChilds->getLength(); ++k) {
0429 if (colTypesChilds->item(k)->getNodeType() == DOMNode::TEXT_NODE) {
0430
0431
0432 char* tStr = xercesc::XMLString::transcode(colTypesChilds->item(k)->getNodeValue());
0433 char *saveptr, first = 1;
0434 for (char* item = strtok_r(tStr, delim.c_str(), &saveptr); item != nullptr;
0435 item = strtok_r(nullptr, delim.c_str(), &saveptr), first = 0)
0436 typesStr += (first ? std::string("") : delim) + pruneString(item);
0437 xercesc::XMLString::release(&tStr);
0438 }
0439 }
0440 }
0441
0442
0443 std::vector<std::string> rowStrs;
0444 DOMNodeList* rowElements = elem->getElementsByTagName(kTagRow);
0445 for (XMLSize_t j = 0; j < rowElements->getLength(); ++j) {
0446 DOMNodeList* rowChilds = rowElements->item(j)->getChildNodes();
0447 for (XMLSize_t k = 0; k < rowChilds->getLength(); ++k) {
0448 if (rowChilds->item(k)->getNodeType() == DOMNode::TEXT_NODE) {
0449
0450
0451
0452 char* rStr = xercesc::XMLString::transcode(rowChilds->item(k)->getNodeValue());
0453 char *saveptr, first = 1;
0454 std::string row;
0455 for (char* item = strtok_r(rStr, delim.c_str(), &saveptr); item != nullptr;
0456 item = strtok_r(nullptr, delim.c_str(), &saveptr), first = 0)
0457 row += (first ? std::string("") : delim) + pruneString(item);
0458
0459 rowStrs.push_back(row);
0460 xercesc::XMLString::release(&rStr);
0461 }
0462 }
0463 }
0464
0465 aTriggerSystem.addTable(
0466 id.c_str(), contextId.c_str(), columnsStr.c_str(), typesStr.c_str(), rowStrs, delim.c_str());
0467
0468 } else {
0469 std::string value = "";
0470 DOMNodeList* valNodes = elem->getChildNodes();
0471 for (XMLSize_t j = 0; j < valNodes->getLength(); ++j) {
0472 if (valNodes->item(j)->getNodeType() == DOMNode::TEXT_NODE) {
0473 value += cms::xerces::toString(valNodes->item(j)->getNodeValue());
0474 }
0475 }
0476
0477
0478 pruneString(value);
0479
0480
0481 aTriggerSystem.addParameter(id.c_str(), contextId.c_str(), type.c_str(), value.c_str(), delim.c_str());
0482 }
0483
0484 } else if (XMLString::equals(elem->getTagName(), kTagMask)) {
0485
0486 std::string id = cms::xerces::toString(elem->getAttribute(kAttrId));
0487
0488 pruneString(id);
0489 aTriggerSystem.addMask(id.c_str(), contextId.c_str());
0490
0491 } else if (XMLString::equals(elem->getTagName(), kTagDisable)) {
0492
0493 std::string id = cms::xerces::toString(elem->getAttribute(kAttrId));
0494 pruneString(id);
0495 aTriggerSystem.disableProcOrRoleOrDaq(id.c_str());
0496 }
0497 }
0498 }
0499 }
0500 }
0501 }
0502
0503 void XmlConfigParser::readContexts(const std::string& key, const std::string& sysId, TriggerSystem& aTriggerSystem) {
0504 DOMElement* keyElement = getKeyElement(key);
0505 if (keyElement) {
0506 for (DOMElement* elem = static_cast<DOMElement*>(keyElement->getFirstChild()); elem;
0507 elem = static_cast<DOMElement*>(elem->getNextSibling())) {
0508 if (elem->getNodeType() == DOMNode::ELEMENT_NODE) {
0509 if (XMLString::equals(elem->getTagName(), kTagAlgo) || XMLString::equals(elem->getTagName(), kTagRunSettings)) {
0510 readContext(elem, sysId, aTriggerSystem);
0511 }
0512 }
0513 }
0514 } else {
0515 throw std::runtime_error("Key not found: " + key);
0516 }
0517 }
0518
0519 DOMElement* XmlConfigParser::getKeyElement(const std::string& key) {
0520 DOMElement* rootElement = doc_->getDocumentElement();
0521 if (XMLString::equals(rootElement->getTagName(), kTagDb)) {
0522 DOMNodeList* keyElements = rootElement->getElementsByTagName(kTagKey);
0523
0524 for (XMLSize_t i = 0; i < keyElements->getLength(); ++i) {
0525 DOMElement* keyElement = static_cast<DOMElement*>(keyElements->item(i));
0526 if (cms::xerces::toString(keyElement->getAttribute(kAttrId)) == key) {
0527 return keyElement;
0528 }
0529 }
0530 }
0531 return nullptr;
0532 }
0533
0534 void XmlConfigParser::buildGlobalDoc(const std::string& key, const std::string& topPath) {
0535 DOMElement* keyElement = getKeyElement(key);
0536 if (keyElement) {
0537 DOMNodeList* loadElements = keyElement->getElementsByTagName(kTagLoad);
0538 for (XMLSize_t i = 0; i < loadElements->getLength(); ++i) {
0539 DOMElement* loadElement = static_cast<DOMElement*>(loadElements->item(i));
0540 std::string fileName = cms::xerces::toString(loadElement->getAttribute(kAttrModule));
0541 if (fileName.find('/') != 0) {
0542
0543 size_t pos;
0544 std::string topDir = "";
0545 pos = topPath.find_last_of('/');
0546 if (pos != std::string::npos) {
0547 topDir = topPath.substr(0, pos + 1);
0548 }
0549 fileName = topDir + fileName;
0550 }
0551
0552 DOMDocument* subDoc = nullptr;
0553 readDOMFromFile(fileName, subDoc);
0554 if (subDoc) {
0555 appendNodesFromSubDoc(keyElement, subDoc);
0556 }
0557 }
0558 }
0559 }
0560
0561 void XmlConfigParser::appendNodesFromSubDoc(DOMNode* parentNode, DOMDocument* subDoc) {
0562 DOMElement* subDocRootElement = subDoc->getDocumentElement();
0563
0564 if (XMLString::equals(subDocRootElement->getTagName(), kTagAlgo) ||
0565 XMLString::equals(subDocRootElement->getTagName(), kTagRunSettings)) {
0566 DOMNode* importedNode = doc_->importNode(subDocRootElement, true);
0567 parentNode->appendChild(importedNode);
0568 }
0569 }
0570
0571
0572 const char XmlConfigParser_reject_symbols[256] = {
0573 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
0574 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0575 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
0576 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0577 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0578 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0579 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0580 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0581 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
0582
0583 char* XmlConfigParser::pruneString(char*& str) {
0584 size_t alphanumBegin = 0, alphanumEnd = strlen(str) - 1;
0585
0586 while (str[alphanumBegin] && XmlConfigParser_reject_symbols[unsigned(str[alphanumBegin])])
0587 alphanumBegin++;
0588 while (alphanumEnd >= alphanumBegin && XmlConfigParser_reject_symbols[unsigned(str[alphanumEnd])])
0589 alphanumEnd--;
0590
0591 str[alphanumEnd + 1] = '\0';
0592 return str + alphanumBegin;
0593 }
0594
0595 void XmlConfigParser::pruneString(std::string& str) {
0596 std::size_t alphanumBegin = str.find_first_not_of("\n\t ");
0597 std::size_t alphanumEnd = str.find_last_not_of("\n\t ");
0598 if (alphanumBegin != std::string::npos) {
0599 if (alphanumEnd != std::string::npos) {
0600 str = str.substr(alphanumBegin, alphanumEnd - alphanumBegin + 1);
0601 } else {
0602 str = str.substr(alphanumBegin);
0603 }
0604 }
0605 }