xmlBase::XmlParser Class Reference

#include <XmlParser.h>

Public Member Functions
	XmlParser (bool throwErrors=false)
void	doSchema (bool doit)
	Call this method to turn on schema processing (else it's off)
	~XmlParser ()
DOMDocument *	parse (const char *const filename, const std::string &docType=std::string(""))
	Parse an xml file, returning document node if successful.
DOMDocument *	parse (const std::string &buffer, const std::string &docType=std::string(""))
	Parse an xml file as a string, returning document node if successful.
void	reset ()

Detailed Description

Definition at line 22 of file XmlParser.h.

Constructor & Destructor Documentation

XmlParser()

xmlBase::XmlParser::XmlParser

(

bool

throwErrors = false

)

Definition at line 39 of file XmlParser.cxx.

                                       : m_throwErrors(throwErrors),
                                           m_doSchema(false) {
    if (!didInit) {
      try {
        XMLPlatformUtils::Initialize();
      }
      catch(const XMLException& toCatch)
      {  // may want to redirect in Gaudi environment
        char*  charMsg = XMLString::transcode(toCatch.getMessage());
        std::string msg = std::string(charMsg);
        XMLString::release(&charMsg);
        
        std::string errMsg("Error during Xerces-c Initialization: \n");
        errMsg += " Exception message: ";
        errMsg += msg;
        if (m_throwErrors) {
          throw ParseException(msg);
        }  else {
          std::cerr << errMsg << std::endl;
          return;
        }
      }
      didInit = 1;
    }
    m_parser = new XercesDOMParser();
 
    m_errorHandler = new XmlErrorHandler(throwErrors);
 
    // According to documentation we shouldn't need this, but
    // just in case..
    m_parser->setValidationScheme(AbstractDOMParser::Val_Auto);
    /*
    m_parser->setDoNamespaces(true);
    m_parser->setDoSchema(true);
    m_parser->setValidationSchemaFullChecking(true);
    */
 
    m_resolver = new EResolver();
    m_parser->setXMLEntityResolver(m_resolver);
    m_parser->setErrorHandler(m_errorHandler);
 
    
 
    // Don't keep entity reference nodes.  We don't use them
    // and they can cause confusion
    m_parser->setCreateEntityReferenceNodes(false);
    // Have to leave this line out for now since it causes weirdness
    // with DOMDocument::getElementById
 
    // As long as we don't need to re-serialize, we can forget about
    // ingnorable white space and save a bit of memory.
    m_parser->setIncludeIgnorableWhitespace(false);
  }

~XmlParser()

xmlBase::XmlParser::~XmlParser

(

)

Definition at line 101 of file XmlParser.cxx.

                        {
    delete m_errorHandler;
    delete m_resolver;
    // delete m_parser;  temporary, until we can figure out why there 
    // are sometimes problems while freeing this piece of memory.
  }

Member Function Documentation

doSchema()

void xmlBase::XmlParser::doSchema

(

bool

doit

)

Call this method to turn on schema processing (else it's off)

Definition at line 92 of file XmlParser.cxx.

                                    {
    m_doSchema = doit;  // just to keep a record of what we think we're doing
 
    //    m_parser->setValidationScheme(AbstractDOMParser::Val_Always);
    m_parser->setDoNamespaces(doit);
    m_parser->setDoSchema(doit);
    m_parser->setValidationSchemaFullChecking(doit);
  }

Referenced by xmlBase::IFile::IFile(), and rdbModel::XercesBuilder::parseInput().

parse() [1/2]

DOMDocument * xmlBase::XmlParser::parse	(	const char *const	filename,
		const std::string &	docType = std::string("")
	)

Parse an xml file, returning document node if successful.

Definition at line 108 of file XmlParser.cxx.

                                                          {
    XERCES_CPP_NAMESPACE_USE
    // Reset from any previous parse
    m_errorsOccurred = false;
    m_resolver->clean();
 
    // translate environment variables, if any
    std::string fname(filename);
    int nExpand = facilities::Util::expandEnvVar(&fname);
    if (nExpand < 0) {
      std::string errMsg("xmlBase::XmlParser::parse ");
      errMsg += "Filename arg. contained untranslatable env. variables";
      if (m_throwErrors) {
        throw 
          ParseException(errMsg);
      } else {
        std::cerr << errMsg << std::endl;
        return 0;
      }
    }
    
    // parse file
    try {
      //      XMLCh* filenameXMLCh = Dom::transToXMLCh(filename);
      XMLCh* filenameXMLCh = XMLString::transcode(fname.c_str());
      LocalFileInputSource fileSource(filenameXMLCh);
      m_parser->parse(fileSource);
      XMLString::release(&filenameXMLCh);
    }
    catch   (const XMLException& e) {
      char* charMsg = XMLString::transcode(e.getMessage());
      std::string msg = std::string(charMsg);
      XMLString::release(&charMsg);
      std::string errMsg("xmlBase::XmlParser::parse ");
      errMsg += "Error occurred while parsing file ";
      errMsg += fname;
      m_errorsOccurred = true;
      m_parser->reset();
      if (m_throwErrors) {
        errMsg += "  ";
        errMsg += msg;
        throw ParseException(errMsg);
      }
      else {
        std::cerr << errMsg << std::endl
                  << "Message: " << msg << std::endl;
        return 0;
      }
 
    }
 
    if (m_errorHandler->getFatalCount() + m_errorHandler->getErrorCount()) {
      // Put out message
      m_parser->reset();  // may be used to parse new input
      return 0;
    }
    if (docType != std::string("")) { // check actual docType matches requested
      bool ok = checkDocType(m_parser->getDocument(), docType);
 
      if (ok) return m_parser->getDocument();
 
      // Either there was no docType at all or it didn't match
      m_parser->reset();
      return 0;
    }
 
    return m_parser->getDocument();
    // if ok return document node; else null
  }

Referenced by xmlBase::IFile::IFile(), main(), rdbModel::MysqlConnection::open(), CalibXmlCnvSvc::parse(), xmlBase::DocMan::parse(), rdbModel::XercesBuilder::parseInput(), and calibUtil::StripSrv::StripSrv().

parse() [2/2]

DOMDocument * xmlBase::XmlParser::parse	(	const std::string &	buffer,
		const std::string &	docType = std::string("")
	)

Parse an xml file as a string, returning document node if successful.

Definition at line 180 of file XmlParser.cxx.

                                                          {
  XERCES_CPP_NAMESPACE_USE
     
  // parse file
    m_errorsOccurred = false;
    try {
      char fakeid =99;
      XMLCh* buffer = XMLString::transcode(input.c_str());
      //      XMLCh* buffer = Dom::transToXMLCh(input.c_str());
 
      unsigned int byteCount = sizeof(XMLCh) * input.length();  
 
      MemBufInputSource source((const unsigned char*)buffer, byteCount, 
                               &fakeid, false);
      m_parser->parse(source);
      XMLString::release(&buffer);
    }
    catch   (const XMLException& e) {
      char* charMsg = XMLString::transcode(e.getMessage());
      std::string msg = std::string(charMsg);
      XMLString::release(&charMsg);
      m_errorsOccurred = true;
      m_parser->reset();
 
      std::string errMsg("xmlBase::XmlParser::parse ");
      errMsg += 
        "An error occurred while parsing MemBufInputSource\n  Message: ";
      if (m_throwErrors) {
        throw ParseException(errMsg);
      } else {
        std::cerr << errMsg << std::endl;
        return 0;
      }
      //      std::string msg(Dom::transToChar(e.getMessage()));
      std::cerr << 
        "An error occurred while parsing MemBufInputSource\n  Message: " <<
        msg << std::endl;
      return 0;
    }
 
    if (m_errorHandler->getFatalCount() + m_errorHandler->getErrorCount()) {
      // Put out message
      m_parser->reset();  // may be used to parse new input
      return 0;
    }
 
    if (docType != std::string("")) { // check actual docType matches requested
      bool ok = checkDocType(m_parser->getDocument(), docType);
 
      if (ok) return m_parser->getDocument();
 
      // Either there was no docType at all or it didn't match
      m_parser->reset();
      return 0;
    }
 
    return m_parser->getDocument();
    // if ok return document node; else null
 
 
  }

reset()

void xmlBase::XmlParser::reset ( )

inline

Reset the parser so it may be used to parse another document (note this destroys old DOM)

Definition at line 41 of file XmlParser.h.

{m_parser->reset();}

Referenced by xmlBase::DocMan::parse().

---

The documentation for this class was generated from the following files:

• XmlParser.h
• XmlParser.cxx