HcalPatternXMLParser.cc

Go to the documentation of this file.

#include "xercesc/sax2/SAX2XMLReader.hpp"
#include <xercesc/sax2/XMLReaderFactory.hpp>
#include "xercesc/sax2/DefaultHandler.hpp"
#include "xercesc/sax2/Attributes.hpp"
#include "FWCore/Utilities/interface/Exception.h"
#include <xercesc/framework/MemBufInputSource.hpp>
XERCES_CPP_NAMESPACE_USE
#include "IORawData/CaloPatterns/interface/HcalPatternXMLParser.h"
#include <ostream>

class HcalPatternXMLParserImpl {
public:
  std::auto_ptr<SAX2XMLReader> parser;
};

HcalPatternXMLParser::HcalPatternXMLParser() {
  m_parser=nullptr;
}
HcalPatternXMLParser::~HcalPatternXMLParser() {
  if (m_parser!=nullptr) delete m_parser;
}

  /*
    Example
    <pre>
    <CFGBrick>
      <Parameter name='IETA' type='int'>14</Parameter>
      <Parameter name='IPHI' type='int'>2</Parameter>
      <Parameter name='DEPTH' type='int'>1</Parameter>
      <Parameter name='CRATE' type='int'>1</Parameter>
      <Parameter name='SLOT' type='int'>8</Parameter>
      <Parameter name='TOPBOTTOM' type='int'>0</Parameter>
      <Parameter name='CHANNEL' type='int'>6</Parameter>
      <Parameter name='LUT_TYPE' type='int'>1</Parameter>
      <Parameter name='CREATIONTAG' type='string'>Identity</Parameter>
      <Parameter name='CREATIONSTAMP' type='string'>2005-03-08 11:44:34</Parameter>
      <Parameter name='FORMATREVISION' type='string'>1</Parameter>
      <Parameter name='TARGETFIRMWARE' type='string'>0</Parameter>
      <Parameter name='GENERALIZEDINDEX' type='int'>140211</Parameter>
      <Data elements='128' encoding='hex'> .. </Data>
    </CFGBrick>
    </pre>
  */

  class ConfigurationDBHandler : public DefaultHandler {
    enum { md_Idle, md_Parameter, md_Data } m_mode;
  public:
    ConfigurationDBHandler(std::map<std::string,std::string>& parameters, std::vector<std::string>& items, std::string& encoding) : m_dataEncoding(encoding), m_items(items), m_parameters(parameters) {
      m_mode=md_Idle;
      xc_Parameter=XMLString::transcode("Parameter");
      xc_Data=XMLString::transcode("Data");
      xc_name=XMLString::transcode("name");
      xc_type=XMLString::transcode("type");
      xc_elements=XMLString::transcode("elements");      
      xc_encoding=XMLString::transcode("encoding");
      m_items.clear();
      m_parameters.clear();
    }
    ~ConfigurationDBHandler() override {
      XMLString::release(&xc_Parameter);
      XMLString::release(&xc_Data);
      XMLString::release(&xc_name);
      XMLString::release(&xc_type);
      XMLString::release(&xc_elements);
      XMLString::release(&xc_encoding);
    }
    void startElement (const XMLCh *const uri, const XMLCh *const localname, const XMLCh *const qname, const Attributes &attrs) override;
    void endElement (const XMLCh *const uri, const XMLCh *const localname, const XMLCh *const qname) override;
    void characters (const XMLCh *const chars, const XMLSize_t length) override;
    void ignorableWhitespace (const XMLCh *const chars, const XMLSize_t length) override;
  private:
    inline bool cvt2String(const XMLCh* val, std::string& ou) {
      if (val==nullptr) return false;
      char* tool=XMLString::transcode(val);
      ou=tool;
      XMLString::release(&tool);
      return true;
    }
    XMLCh *xc_Parameter, *xc_Data, *xc_name, *xc_type, *xc_elements, *xc_encoding;
    std::string m_pname, m_ptype, m_text;
    int n_elements;
    std::string& m_dataEncoding;
    std::vector<std::string>& m_items;
    std::map<std::string,std::string>& m_parameters;
    char m_workc[512];
    XMLCh m_workx[256];
  };

  void ConfigurationDBHandler::startElement (const XMLCh *const uri, const XMLCh *const localname, const XMLCh *const qname, const Attributes &attrs) {
    if (m_mode!=md_Idle) return; 
    if (!XMLString::compareIString(localname,xc_Parameter)) {
      // parameter name
      if (!cvt2String(attrs.getValue(xc_name),m_pname)) return;
      // parameter type
      if (!cvt2String(attrs.getValue(xc_type),m_ptype)) return;
      // switch mode
      m_mode=md_Parameter;
      m_text="";
    } else if (!XMLString::compareIString(localname,xc_Data)) {
      // elements
      std::string strElements;
      if (!cvt2String(attrs.getValue(xc_elements),strElements)) return;
      n_elements=atoi(strElements.c_str());
      // encoding
      m_dataEncoding="";
      cvt2String(attrs.getValue(xc_encoding),m_dataEncoding);
      // switch mode
      m_mode=md_Data;
      m_text="";
    }
   
  }
  void ConfigurationDBHandler::endElement (const XMLCh *const uri, const XMLCh *const localname, const XMLCh *const qname) {
    if (m_mode==md_Idle) return;

    if (m_mode==md_Parameter) {
      m_parameters[m_pname]=m_text; // ignore the type for now...
    } else if (m_mode==md_Data) {
      // parse the text
      std::string entry;
      for (std::string::iterator q=m_text.begin(); q!=m_text.end(); q++) {
    if (isspace(*q)) {
      if (entry.empty()) continue;
      m_items.push_back(entry);
      entry="";
    } else entry+=*q;
      }
    }

    m_mode=md_Idle;
  }
  void ConfigurationDBHandler::ignorableWhitespace(const   XMLCh* chars, const XMLSize_t length) {
    if (m_mode==md_Idle) return;
    m_text+=' ';
  }
  void ConfigurationDBHandler::characters(const XMLCh* chars, const XMLSize_t length) {
    if (m_mode==md_Idle) return;
    unsigned int offset=0;
    while (offset<length) {
      unsigned int i=0;
      for (i=0; i<length-offset && i<255; i++) m_workx[i]=chars[i+offset];
      m_workx[i]=0; // terminate string
      XMLString::transcode(m_workx,m_workc,511);
      m_text+=m_workc;
      offset+=i;
    }
  }

void HcalPatternXMLParser::parse(const std::string& xmlDocument, std::map<std::string,std::string>& parameters, std::vector<std::string>& items, std::string& encoding) {
    // uses XERCES SAX2 parser
    ConfigurationDBHandler handler(parameters,items,encoding);
    
    try {
      if (m_parser==nullptr) {
    m_parser=new HcalPatternXMLParserImpl();
    m_parser->parser=std::auto_ptr<xercesc::SAX2XMLReader>(xercesc::XMLReaderFactory::createXMLReader());
      }
     
      MemBufInputSource src((const unsigned char*)xmlDocument.c_str(), xmlDocument.length(),"hcal::PatternReader");
      m_parser->parser->setContentHandler(&handler);
      m_parser->parser->parse(src);
    } catch (std::exception& ex) {
      throw cms::Exception("ParseError") << ex.what();
    }
  }

void HcalPatternXMLParser::parse(const std::string& xmlDocument, std::map<std::string,std::string>& parameters, std::vector<uint32_t>& data) {
  std::vector<std::string> items;
  std::string encoding;

  this->parse(xmlDocument,parameters,items,encoding);
  int formatting=0;
  if (encoding=="dec") formatting=10;
  if (encoding=="hex") formatting=16;

  data.clear();
  for (std::vector<std::string>::const_iterator i=items.begin(); i!=items.end(); i++)
    data.push_back(strtol(i->c_str(),nullptr,formatting));

}