xmlBase::XmlParser Class Reference

#include <XmlParser.h>

List of all members.

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 ()
Private Attributes
XercesDOMParser *	m_parser
	Xerces-supplied parser which does the real work.
XmlErrorHandler *	m_errorHandler
EResolver *	m_resolver
	Entity resolver.
bool	m_throwErrors
bool	m_errorsOccurred
bool	m_doSchema
Static Private Attributes
static int	didInit = 0

---

Detailed Description

Definition at line 22 of file XmlParser.h.

---

Constructor & Destructor Documentation

xmlBase::XmlParser::XmlParser

(

bool

throwErrors = false

)

Definition at line 39 of file XmlParser.cxx.

References didInit, m_errorHandler, m_parser, m_resolver, m_throwErrors, release, and deljobs::string.

                                       : 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);
  }

xmlBase::XmlParser::~XmlParser

(

)

Definition at line 101 of file XmlParser.cxx.

References m_errorHandler, and m_resolver.

                        {
    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

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.

References m_doSchema, and m_parser.

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

                                    {
    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);
  }

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.

References checkDocType(), xmlBase::XmlErrorHandler::getErrorCount(), xmlBase::XmlErrorHandler::getFatalCount(), m_errorHandler, m_errorsOccurred, m_parser, m_throwErrors, release, and deljobs::string.

                                                          {
  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


  }

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.

References checkDocType(), xmlBase::EResolver::clean(), fname, xmlBase::XmlErrorHandler::getErrorCount(), xmlBase::XmlErrorHandler::getFatalCount(), m_errorHandler, m_errorsOccurred, m_parser, m_resolver, m_throwErrors, release, and deljobs::string.

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

                                                          {
    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
  }

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.

References m_parser.

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

{m_parser->reset();}

---

Member Data Documentation

XERCES_CPP_NAMESPACE_USE int xmlBase::XmlParser::didInit = 0 [static, private]

Definition at line 51 of file XmlParser.h.

Referenced by XmlParser().

bool xmlBase::XmlParser::m_doSchema [private]

Definition at line 50 of file XmlParser.h.

Referenced by doSchema().

XmlErrorHandler* xmlBase::XmlParser::m_errorHandler [private]

Definition at line 45 of file XmlParser.h.

Referenced by parse(), XmlParser(), and ~XmlParser().

bool xmlBase::XmlParser::m_errorsOccurred [private]

Definition at line 49 of file XmlParser.h.

Referenced by parse().

XercesDOMParser* xmlBase::XmlParser::m_parser [private]

Xerces-supplied parser which does the real work.

Definition at line 44 of file XmlParser.h.

Referenced by doSchema(), parse(), reset(), and XmlParser().

EResolver* xmlBase::XmlParser::m_resolver [private]

Entity resolver.

Definition at line 47 of file XmlParser.h.

Referenced by parse(), XmlParser(), and ~XmlParser().

bool xmlBase::XmlParser::m_throwErrors [private]

Definition at line 48 of file XmlParser.h.

Referenced by parse(), and XmlParser().

---