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 ()
	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 ()
	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 20 of file Calibration/xmlBase/include/xmlBase/XmlParser.h.

Constructor & Destructor Documentation

XmlParser() [1/3]

xmlBase::XmlParser::XmlParser

(

bool

throwErrors = false

)

Definition at line 37 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() [1/3]

xmlBase::XmlParser::~XmlParser

(

)

Definition at line 96 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.
  }

XmlParser() [2/3]

xmlBase::XmlParser::XmlParser

(

bool

throwErrors = false

)

~XmlParser() [2/3]

xmlBase::XmlParser::~XmlParser

(

)

XmlParser() [3/3]

xmlBase::XmlParser::XmlParser

(

bool

throwErrors = false

)

~XmlParser() [3/3]

xmlBase::XmlParser::~XmlParser

(

)

Member Function Documentation

doSchema() [1/3]

void xmlBase::XmlParser::doSchema

(

bool

doit

)

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

Definition at line 87 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().

doSchema() [2/3]

void xmlBase::XmlParser::doSchema

(

bool

doit

)

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

doSchema() [3/3]

void xmlBase::XmlParser::doSchema

(

bool

doit

)

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

parse() [1/6]

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 103 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(), main(), rdbModel::MysqlConnection::open(), rdbModel::XercesBuilder::parseInput(), and calibUtil::StripSrv::StripSrv().

parse() [2/6]

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

Parse an xml file, returning document node if successful.

parse() [3/6]

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

Parse an xml file, returning document node if successful.

parse() [4/6]

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

parse() [5/6]

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.

parse() [6/6]

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.

reset() [1/3]

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 38 of file Calibration/xmlBase/include/xmlBase/XmlParser.h.

{ m_parser->reset(); }

reset() [2/3]

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 38 of file InstallArea/x86_64-el9-gcc13-dbg/include/xmlBase/XmlParser.h.

{ m_parser->reset(); }

reset() [3/3]

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 38 of file InstallArea/x86_64-el9-gcc13-opt/include/xmlBase/XmlParser.h.

{ m_parser->reset(); }

---

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

• Calibration/xmlBase/include/xmlBase/XmlParser.h
• InstallArea/x86_64-el9-gcc13-dbg/include/xmlBase/XmlParser.h
• InstallArea/x86_64-el9-gcc13-opt/include/xmlBase/XmlParser.h
• XmlParser.cxx