Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

xmlBase::XmlParser Class Reference

#include <XmlParser.h>

List of all members.

Public Member Functions

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

Private Attributes

bool m_doSchema
XmlErrorHandler * m_errorHandler
XmlErrorHandler * m_errorHandler
bool m_errorsOccurred
XercesDOMParser * m_parser
 Xerces-supplied parser which does the real work.
XercesDOMParser * m_parser
 Xerces-supplied parser which does the real work.
EResolver * m_resolver
 Entity resolver.
EResolver * m_resolver
 Entity resolver.
bool m_throwErrors

Static Private Attributes

int didInit = 0

Constructor & Destructor Documentation

xmlBase::XmlParser::XmlParser (  bool  throwErrors = false  ) 
  

00039                                        : m_throwErrors(throwErrors),
00040                                            m_doSchema(false) {
00041     if (!didInit) {
00042       try {
00043         XMLPlatformUtils::Initialize();
00044       }
00045       catch(const XMLException& toCatch)
00046       {  // may want to redirect in Gaudi environment
00047         char*  charMsg = XMLString::transcode(toCatch.getMessage());
00048         std::string msg = std::string(charMsg);
00049         XMLString::release(&charMsg);
00050         
00051         std::string errMsg("Error during Xerces-c Initialization: \n");
00052         errMsg += " Exception message: ";
00053         errMsg += msg;
00054         if (m_throwErrors) {
00055           throw ParseException(msg);
00056         }  else {
00057           std::cerr << errMsg << std::endl;
00058           return;
00059         }
00060       }
00061       didInit = 1;
00062     }
00063     m_parser = new XercesDOMParser();
00064 
00065     m_errorHandler = new XmlErrorHandler(throwErrors);
00066 
00067     // According to documentation we shouldn't need this, but
00068     // just in case..
00069     m_parser->setValidationScheme(AbstractDOMParser::Val_Auto);
00070     /*
00071     m_parser->setDoNamespaces(true);
00072     m_parser->setDoSchema(true);
00073     m_parser->setValidationSchemaFullChecking(true);
00074     */
00075 
00076     m_resolver = new EResolver();
00077     m_parser->setXMLEntityResolver(m_resolver);
00078     m_parser->setErrorHandler(m_errorHandler);
00079 
00080     
00081 
00082     // Don't keep entity reference nodes.  We don't use them
00083     // and they can cause confusion
00084     m_parser->setCreateEntityReferenceNodes(false);
00085     // Have to leave this line out for now since it causes weirdness
00086     // with DOMDocument::getElementById
00087 
00088     // As long as we don't need to re-serialize, we can forget about
00089     // ingnorable white space and save a bit of memory.
00090     m_parser->setIncludeIgnorableWhitespace(false);
00091   }

xmlBase::XmlParser::~XmlParser (   ) 
  

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

xmlBase::XmlParser::XmlParser (  bool  throwErrors = false  ) 
 

xmlBase::XmlParser::~XmlParser (   ) 
 

Member Function Documentation

void xmlBase::XmlParser::doSchema (  bool  doit  ) 
 

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

void xmlBase::XmlParser::doSchema (  bool  doit  ) 
 

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

00092                                     {
00093     m_doSchema = doit;  // just to keep a record of what we think we're doing
00094 
00095     //    m_parser->setValidationScheme(AbstractDOMParser::Val_Always);
00096     m_parser->setDoNamespaces(doit);
00097     m_parser->setDoSchema(doit);
00098     m_parser->setValidationSchemaFullChecking(doit);
00099   }

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.

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

Parse an xml file, returning document node if successful.

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. 

00181                                                           {
00182   XERCES_CPP_NAMESPACE_USE
00183      
00184   // parse file
00185     m_errorsOccurred = false;
00186     try {
00187       char fakeid =99;
00188       XMLCh* buffer = XMLString::transcode(input.c_str());
00189       //      XMLCh* buffer = Dom::transToXMLCh(input.c_str());
00190 
00191       unsigned int byteCount = sizeof(XMLCh) * input.length();  
00192 
00193       MemBufInputSource source((const unsigned char*)buffer, byteCount, 
00194                                &fakeid, false);
00195       m_parser->parse(source);
00196       XMLString::release(&buffer);
00197     }
00198     catch   (const XMLException& e) {
00199       char* charMsg = XMLString::transcode(e.getMessage());
00200       std::string msg = std::string(charMsg);
00201       XMLString::release(&charMsg);
00202       m_errorsOccurred = true;
00203       m_parser->reset();
00204 
00205       std::string errMsg("xmlBase::XmlParser::parse ");
00206       errMsg += 
00207         "An error occurred while parsing MemBufInputSource\n  Message: ";
00208       if (m_throwErrors) {
00209         throw ParseException(errMsg);
00210       } else {
00211         std::cerr << errMsg << std::endl;
00212         return 0;
00213       }
00214       //      std::string msg(Dom::transToChar(e.getMessage()));
00215       std::cerr << 
00216         "An error occurred while parsing MemBufInputSource\n  Message: " <<
00217         msg << std::endl;
00218       return 0;
00219     }
00220 
00221     if (m_errorHandler->getFatalCount() + m_errorHandler->getErrorCount()) {
00222       // Put out message
00223       m_parser->reset();  // may be used to parse new input
00224       return 0;
00225     }
00226 
00227     if (docType != std::string("")) { // check actual docType matches requested
00228       bool ok = checkDocType(m_parser->getDocument(), docType);
00229 
00230       if (ok) return m_parser->getDocument();
00231 
00232       // Either there was no docType at all or it didn't match
00233       m_parser->reset();
00234       return 0;
00235     }
00236 
00237     return m_parser->getDocument();
00238     // if ok return document node; else null
00239 
00240 
00241   }

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

Parse an xml file, returning document node if successful. 

00109                                                           {
00110     XERCES_CPP_NAMESPACE_USE
00111     // Reset from any previous parse
00112     m_errorsOccurred = false;
00113     m_resolver->clean();
00114 
00115     // translate environment variables, if any
00116     std::string fname(filename);
00117     int nExpand = facilities::Util::expandEnvVar(&fname);
00118     if (nExpand < 0) {
00119       std::string errMsg("xmlBase::XmlParser::parse ");
00120       errMsg += "Filename arg. contained untranslatable env. variables";
00121       if (m_throwErrors) {
00122         throw 
00123           ParseException(errMsg);
00124       } else {
00125         std::cerr << errMsg << std::endl;
00126         return 0;
00127       }
00128     }
00129     
00130     // parse file
00131     try {
00132       //      XMLCh* filenameXMLCh = Dom::transToXMLCh(filename);
00133       XMLCh* filenameXMLCh = XMLString::transcode(fname.c_str());
00134       LocalFileInputSource fileSource(filenameXMLCh);
00135       m_parser->parse(fileSource);
00136       XMLString::release(&filenameXMLCh);
00137     }
00138     catch   (const XMLException& e) {
00139       char* charMsg = XMLString::transcode(e.getMessage());
00140       std::string msg = std::string(charMsg);
00141       XMLString::release(&charMsg);
00142       std::string errMsg("xmlBase::XmlParser::parse ");
00143       errMsg += "Error occurred while parsing file ";
00144       errMsg += fname;
00145       m_errorsOccurred = true;
00146       m_parser->reset();
00147       if (m_throwErrors) {
00148         errMsg += "  ";
00149         errMsg += msg;
00150         throw ParseException(errMsg);
00151       }
00152       else {
00153         std::cerr << errMsg << std::endl
00154                   << "Message: " << msg << std::endl;
00155         return 0;
00156       }
00157 
00158     }
00159 
00160     if (m_errorHandler->getFatalCount() + m_errorHandler->getErrorCount()) {
00161       // Put out message
00162       m_parser->reset();  // may be used to parse new input
00163       return 0;
00164     }
00165     if (docType != std::string("")) { // check actual docType matches requested
00166       bool ok = checkDocType(m_parser->getDocument(), docType);
00167 
00168       if (ok) return m_parser->getDocument();
00169 
00170       // Either there was no docType at all or it didn't match
00171       m_parser->reset();
00172       return 0;
00173     }
00174 
00175     return m_parser->getDocument();
00176     // if ok return document node; else null
00177   }

void xmlBase::XmlParser::reset (   )  [inline]
 

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

00041 {m_parser->reset();}

void xmlBase::XmlParser::reset (   )  [inline]
 

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

00041 {m_parser->reset();}

Member Data Documentation

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

bool xmlBase::XmlParser::m_doSchema [private]
 

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

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

bool xmlBase::XmlParser::m_errorsOccurred [private]
 

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

Xerces-supplied parser which does the real work.

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

Xerces-supplied parser which does the real work.

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

Entity resolver.

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

Entity resolver.

bool xmlBase::XmlParser::m_throwErrors [private]
 

The documentation for this class was generated from the following files:
Generated on Wed Feb 2 19:25:05 2011 for BOSS6.5.5 by  doxygen 1.3.9.1