MonitorXMLParser.cc

Go to the documentation of this file.

#include "FWCore/Concurrency/interface/Xerces.h"

#include <xercesc/dom/DOMDocument.hpp>
#include <xercesc/dom/DOMNodeList.hpp>

#include <sstream>
#include <stdexcept>

#include "DQM/EcalMonitorDbModule/interface/MonitorXMLParser.h"

MonitorXMLParser::MonitorXMLParser(const std::string &fromFile) {
  try {
    cms::concurrency::xercesInitialize();

  } catch (xercesc::XMLException &e) {
    char *message = xercesc::XMLString::transcode(e.getMessage());

    std::cerr << "XML toolkit initialization error: " << message << std::endl;

    xercesc::XMLString::release(&message);

    exit(ERROR_XERCES_INIT);
  }

  xmlFile_ = fromFile;
  parser_ = new xercesc::XercesDOMParser();
  tags_ = new TagNames();
}

// - - - - - - - - - - - - - - - - -

MonitorXMLParser::~MonitorXMLParser() throw() {
  try {
    cms::concurrency::xercesTerminate();
  } catch (xercesc::XMLException &e) {
    char *message = xercesc::XMLString::transcode(e.getMessage());
    std::cerr << "XML toolkit teardown error: " << message << std::endl;
    xercesc::XMLString::release(&message);
  }

  delete parser_;
  delete tags_;
}

// - - - - - - - - - - - - - - - - -

void MonitorXMLParser::handleElement(xercesc::DOMElement *element) {
  if (xercesc::XMLString::equals(tags_->TAG_ME, element->getTagName())) {
    char *c;
    std::stringstream s;
    DB_ME me;
    bool meok;

    meok = false;

    xercesc::DOMNodeList *d1Nodes = element->getElementsByTagName(tags_->TAG_1D);
    const XMLSize_t d1Count = d1Nodes->getLength();

    for (XMLSize_t d1Index = 0; d1Index < d1Count; ++d1Index) {
      xercesc::DOMNode *d1Node = d1Nodes->item(d1Index);

      xercesc::DOMElement *d1Element = dynamic_cast<xercesc::DOMElement *>(d1Node);

      const XMLCh *d1titleXMLCh = d1Element->getAttribute(tags_->ATTR_TITLE);
      c = xercesc::XMLString::transcode(d1titleXMLCh);
      me.type = "th1d";
      me.title = c;
      meok = true;
      xercesc::XMLString::release(&c);

      const XMLCh *d1xbinsXMLCh = d1Element->getAttribute(tags_->ATTR_XBINS);
      c = xercesc::XMLString::transcode(d1xbinsXMLCh);
      s.clear();
      s.str(c);
      s >> me.xbins;
      xercesc::XMLString::release(&c);

      const XMLCh *d1xfromXMLCh = d1Element->getAttribute(tags_->ATTR_XFROM);
      c = xercesc::XMLString::transcode(d1xfromXMLCh);
      s.clear();
      s.str(c);
      s >> me.xfrom;
      xercesc::XMLString::release(&c);

      const XMLCh *d1xtoXMLCh = d1Element->getAttribute(tags_->ATTR_XTO);
      c = xercesc::XMLString::transcode(d1xtoXMLCh);
      s.clear();
      s.str(c);
      s >> me.xto;
      xercesc::XMLString::release(&c);

      const XMLCh *d1ncycleXMLCh = d1Element->getAttribute(tags_->ATTR_NCYCLE);
      c = xercesc::XMLString::transcode(d1ncycleXMLCh);
      s.clear();
      s.str(c);
      s >> me.ncycle;
      xercesc::XMLString::release(&c);

      const XMLCh *d1loopXMLCh = d1Element->getAttribute(tags_->ATTR_LOOP);
      c = xercesc::XMLString::transcode(d1loopXMLCh);
      s.clear();
      s.str(c);
      s >> me.loop;
      xercesc::XMLString::release(&c);

      me.ybins = 0;
      me.yfrom = 0.0;
      me.yto = 0.0;
      me.zbins = 0;
      me.zfrom = 0.0;
      me.zto = 0.0;
    }

    xercesc::DOMNodeList *d2Nodes = element->getElementsByTagName(tags_->TAG_2D);
    const XMLSize_t d2Count = d2Nodes->getLength();

    for (XMLSize_t d2Index = 0; d2Index < d2Count; ++d2Index) {
      xercesc::DOMNode *d2Node = d2Nodes->item(d2Index);

      xercesc::DOMElement *d2Element = dynamic_cast<xercesc::DOMElement *>(d2Node);

      const XMLCh *d2titleXMLCh = d2Element->getAttribute(tags_->ATTR_TITLE);
      c = xercesc::XMLString::transcode(d2titleXMLCh);
      me.type = "th2d";
      me.title = c;
      meok = true;
      xercesc::XMLString::release(&c);

      const XMLCh *d2xbinsXMLCh = d2Element->getAttribute(tags_->ATTR_XBINS);
      c = xercesc::XMLString::transcode(d2xbinsXMLCh);
      s.clear();
      s.str(c);
      s >> me.xbins;
      xercesc::XMLString::release(&c);

      const XMLCh *d2xfromXMLCh = d2Element->getAttribute(tags_->ATTR_XFROM);
      c = xercesc::XMLString::transcode(d2xfromXMLCh);
      s.clear();
      s.str(c);
      s >> me.xfrom;
      xercesc::XMLString::release(&c);

      const XMLCh *d2xtoXMLCh = d2Element->getAttribute(tags_->ATTR_XTO);
      c = xercesc::XMLString::transcode(d2xtoXMLCh);
      s.clear();
      s.str(c);
      s >> me.xto;
      xercesc::XMLString::release(&c);

      const XMLCh *d2ybinsXMLCh = d2Element->getAttribute(tags_->ATTR_YBINS);
      c = xercesc::XMLString::transcode(d2ybinsXMLCh);
      s.clear();
      s.str(c);
      s >> me.ybins;
      xercesc::XMLString::release(&c);

      const XMLCh *d2yfromXMLCh = d2Element->getAttribute(tags_->ATTR_YFROM);
      c = xercesc::XMLString::transcode(d2yfromXMLCh);
      s.clear();
      s.str(c);
      s >> me.yfrom;
      xercesc::XMLString::release(&c);

      const XMLCh *d2ytoXMLCh = d2Element->getAttribute(tags_->ATTR_YTO);
      c = xercesc::XMLString::transcode(d2ytoXMLCh);
      s.clear();
      s.str(c);
      s >> me.yto;
      xercesc::XMLString::release(&c);

      const XMLCh *d2ncycleXMLCh = d2Element->getAttribute(tags_->ATTR_NCYCLE);
      c = xercesc::XMLString::transcode(d2ncycleXMLCh);
      s.clear();
      s.str(c);
      s >> me.ncycle;
      xercesc::XMLString::release(&c);

      const XMLCh *d2loopXMLCh = d2Element->getAttribute(tags_->ATTR_LOOP);
      c = xercesc::XMLString::transcode(d2loopXMLCh);
      s.clear();
      s.str(c);
      s >> me.loop;
      xercesc::XMLString::release(&c);

      me.zbins = 0;
      me.zfrom = 0.0;
      me.zto = 0.0;
    }

    xercesc::DOMNodeList *tpNodes = element->getElementsByTagName(tags_->TAG_TPROFILE);
    const XMLSize_t tpCount = tpNodes->getLength();

    for (XMLSize_t tpIndex = 0; tpIndex < tpCount; ++tpIndex) {
      xercesc::DOMNode *tpNode = tpNodes->item(tpIndex);

      xercesc::DOMElement *tpElement = dynamic_cast<xercesc::DOMElement *>(tpNode);

      const XMLCh *tptitleXMLCh = tpElement->getAttribute(tags_->ATTR_TITLE);
      c = xercesc::XMLString::transcode(tptitleXMLCh);
      me.type = "tprofile";
      me.title = c;
      meok = true;
      xercesc::XMLString::release(&c);

      const XMLCh *tpxbinsXMLCh = tpElement->getAttribute(tags_->ATTR_XBINS);
      c = xercesc::XMLString::transcode(tpxbinsXMLCh);
      s.clear();
      s.str(c);
      s >> me.xbins;
      xercesc::XMLString::release(&c);

      const XMLCh *tpxfromXMLCh = tpElement->getAttribute(tags_->ATTR_XFROM);
      c = xercesc::XMLString::transcode(tpxfromXMLCh);
      s.clear();
      s.str(c);
      s >> me.xfrom;
      xercesc::XMLString::release(&c);

      const XMLCh *tpxtoXMLCh = tpElement->getAttribute(tags_->ATTR_XTO);
      c = xercesc::XMLString::transcode(tpxtoXMLCh);
      s.clear();
      s.str(c);
      s >> me.xto;
      xercesc::XMLString::release(&c);

      const XMLCh *tpybinsXMLCh = tpElement->getAttribute(tags_->ATTR_YBINS);
      c = xercesc::XMLString::transcode(tpybinsXMLCh);
      s.clear();
      s.str(c);
      s >> me.ybins;
      xercesc::XMLString::release(&c);

      const XMLCh *tpyfromXMLCh = tpElement->getAttribute(tags_->ATTR_YFROM);
      c = xercesc::XMLString::transcode(tpyfromXMLCh);
      s.clear();
      s.str(c);
      s >> me.yfrom;
      xercesc::XMLString::release(&c);

      const XMLCh *tpytoXMLCh = tpElement->getAttribute(tags_->ATTR_YTO);
      c = xercesc::XMLString::transcode(tpytoXMLCh);
      s.clear();
      s.str(c);
      s >> me.yto;
      xercesc::XMLString::release(&c);

      const XMLCh *tpncycleXMLCh = tpElement->getAttribute(tags_->ATTR_NCYCLE);
      c = xercesc::XMLString::transcode(tpncycleXMLCh);
      s.clear();
      s.str(c);
      s >> me.ncycle;
      xercesc::XMLString::release(&c);

      const XMLCh *tploopXMLCh = tpElement->getAttribute(tags_->ATTR_LOOP);
      c = xercesc::XMLString::transcode(tploopXMLCh);
      s.clear();
      s.str(c);
      s >> me.loop;
      xercesc::XMLString::release(&c);

      me.zbins = 0;
      me.zfrom = 0.0;
      me.zto = 0.0;
    }

    xercesc::DOMNodeList *tp2dNodes = element->getElementsByTagName(tags_->TAG_TPROFILE2D);
    const XMLSize_t tp2dCount = tp2dNodes->getLength();

    for (XMLSize_t tp2dIndex = 0; tp2dIndex < tp2dCount; ++tp2dIndex) {
      xercesc::DOMNode *tp2dNode = tp2dNodes->item(tp2dIndex);

      xercesc::DOMElement *tp2dElement = dynamic_cast<xercesc::DOMElement *>(tp2dNode);

      const XMLCh *tp2dtitleXMLCh = tp2dElement->getAttribute(tags_->ATTR_TITLE);
      c = xercesc::XMLString::transcode(tp2dtitleXMLCh);
      me.type = "tprofile2d";
      me.title = c;
      meok = true;
      xercesc::XMLString::release(&c);

      const XMLCh *tp2dxbinsXMLCh = tp2dElement->getAttribute(tags_->ATTR_XBINS);
      c = xercesc::XMLString::transcode(tp2dxbinsXMLCh);
      s.clear();
      s.str(c);
      s >> me.xbins;
      xercesc::XMLString::release(&c);

      const XMLCh *tp2dxfromXMLCh = tp2dElement->getAttribute(tags_->ATTR_XFROM);
      c = xercesc::XMLString::transcode(tp2dxfromXMLCh);
      s.clear();
      s.str(c);
      s >> me.xfrom;
      xercesc::XMLString::release(&c);

      const XMLCh *tp2dxtoXMLCh = tp2dElement->getAttribute(tags_->ATTR_XTO);
      c = xercesc::XMLString::transcode(tp2dxtoXMLCh);
      s.clear();
      s.str(c);
      s >> me.xto;
      xercesc::XMLString::release(&c);

      const XMLCh *tp2dybinsXMLCh = tp2dElement->getAttribute(tags_->ATTR_YBINS);
      c = xercesc::XMLString::transcode(tp2dybinsXMLCh);
      s.clear();
      s.str(c);
      s >> me.ybins;
      xercesc::XMLString::release(&c);

      const XMLCh *tp2dyfromXMLCh = tp2dElement->getAttribute(tags_->ATTR_YFROM);
      c = xercesc::XMLString::transcode(tp2dyfromXMLCh);
      s.clear();
      s.str(c);
      s >> me.yfrom;
      xercesc::XMLString::release(&c);

      const XMLCh *tp2dytoXMLCh = tp2dElement->getAttribute(tags_->ATTR_YTO);
      c = xercesc::XMLString::transcode(tp2dytoXMLCh);
      s.clear();
      s.str(c);
      s >> me.yto;
      xercesc::XMLString::release(&c);

      const XMLCh *tp2dzbinsXMLCh = tp2dElement->getAttribute(tags_->ATTR_ZBINS);
      c = xercesc::XMLString::transcode(tp2dzbinsXMLCh);
      s.clear();
      s.str(c);
      s >> me.zbins;
      xercesc::XMLString::release(&c);

      const XMLCh *tp2dzfromXMLCh = tp2dElement->getAttribute(tags_->ATTR_ZFROM);
      c = xercesc::XMLString::transcode(tp2dzfromXMLCh);
      s.clear();
      s.str(c);
      s >> me.zfrom;
      xercesc::XMLString::release(&c);

      const XMLCh *tp2dztoXMLCh = tp2dElement->getAttribute(tags_->ATTR_ZTO);
      c = xercesc::XMLString::transcode(tp2dztoXMLCh);
      s.clear();
      s.str(c);
      s >> me.zto;
      xercesc::XMLString::release(&c);

      const XMLCh *tp2dncycleXMLCh = tp2dElement->getAttribute(tags_->ATTR_NCYCLE);
      c = xercesc::XMLString::transcode(tp2dncycleXMLCh);
      s.clear();
      s.str(c);
      s >> me.ncycle;
      xercesc::XMLString::release(&c);

      const XMLCh *tp2dloopXMLCh = tp2dElement->getAttribute(tags_->ATTR_LOOP);
      c = xercesc::XMLString::transcode(tp2dloopXMLCh);
      s.clear();
      s.str(c);
      s >> me.loop;
      xercesc::XMLString::release(&c);
    }

    xercesc::DOMNodeList *qNodes = element->getElementsByTagName(tags_->TAG_QUERY);
    const XMLSize_t qCount = qNodes->getLength();

    for (XMLSize_t qIndex = 0; qIndex < qCount; ++qIndex) {
      xercesc::DOMNode *qNode = qNodes->item(qIndex);

      xercesc::DOMElement *qElement = dynamic_cast<xercesc::DOMElement *>(qNode);

      const XMLCh *nameXMLCh = qElement->getAttribute(tags_->ATTR_NAME);
      c = xercesc::XMLString::transcode(nameXMLCh);

      const XMLCh *argXMLCh = qElement->getAttribute(tags_->ATTR_ARG);
      char *d = xercesc::XMLString::transcode(argXMLCh);

      const XMLCh *aliasXMLCh = qElement->getAttribute(tags_->ATTR_ALIAS);
      char *e = xercesc::XMLString::transcode(aliasXMLCh);

      DbQuery tmpQuery;
      tmpQuery.query = c;
      tmpQuery.arg = d;
      tmpQuery.alias = e;

      me.queries.push_back(tmpQuery);

      xercesc::XMLString::release(&c);
      xercesc::XMLString::release(&d);
      xercesc::XMLString::release(&e);
    }

    if (meok)
      DBMonitoringElements_.push_back(me);
  }
}  // handleElement()

// - - - - - - - - - - - - - - - - - - -

void MonitorXMLParser::load() noexcept(false) {
  parser_->setValidationScheme(xercesc::XercesDOMParser::Val_Never);
  parser_->setDoNamespaces(false);
  parser_->setDoSchema(false);
  parser_->setLoadExternalDTD(false);

  try {
    parser_->parse(xmlFile_.c_str());

    xercesc::DOMDocument *xmlDoc = parser_->getDocument();

    xercesc::DOMElement *dbe = xmlDoc->getDocumentElement();

    if (nullptr == dbe) {
      throw(std::runtime_error("empty XML document"));
    }

    if (xercesc::XMLString::equals(tags_->TAG_DBE, dbe->getTagName())) {
      xercesc::DOMNodeList *children = dbe->getChildNodes();
      const XMLSize_t nodeCount = children->getLength();

      for (XMLSize_t ix = 0; ix < nodeCount; ++ix) {
        xercesc::DOMNode *currentNode = children->item(ix);
        if (nullptr == currentNode) {
          // null node...
          continue;
        }

        if (xercesc::DOMNode::ELEMENT_NODE != currentNode->getNodeType()) {
          continue;
        }

        xercesc::DOMElement *currentElement = dynamic_cast<xercesc::DOMElement *>(currentNode);

        handleElement(currentElement);
      }
    }

  } catch (xercesc::XMLException &e) {
    char *message = xercesc::XMLString::transcode(e.getMessage());

    std::ostringstream buf;
    buf << "Error parsing file: " << message << std::endl;

    xercesc::XMLString::release(&message);

    throw(std::runtime_error(buf.str()));

  } catch (const xercesc::DOMException &e) {
    char *message = xercesc::XMLString::transcode(e.getMessage());

    std::ostringstream buf;
    buf << "Encountered DOM Exception: " << message << std::endl;

    xercesc::XMLString::release(&message);

    throw(std::runtime_error(buf.str()));
  }

  return;

}  // load()