00001
00002
00003
00004 #include <xercesc/dom/DOM.hpp>
00005 #include <xercesc/framework/LocalFileInputSource.hpp>
00006 #include <xercesc/framework/MemBufInputSource.hpp>
00007 #include <xercesc/util/XMLString.hpp>
00008 #include <xercesc/util/PlatformUtils.hpp>
00009 #include <xercesc/util/XMLUni.hpp>
00010 #include <xercesc/sax/ErrorHandler.hpp>
00011 #include <xercesc/sax/SAXParseException.hpp>
00012 #include <xercesc/parsers/XercesDOMParser.hpp>
00013
00014 #include <string>
00015 #include <iostream>
00016
00017 XERCES_CPP_NAMESPACE_USE
00018 class XmlErrorHandler : public ErrorHandler {
00019 public:
00020 XmlErrorHandler(std::ostream& errOut=std::cerr) : m_errOut(errOut)
00021 {resetErrors();}
00022 ~XmlErrorHandler() {}
00023 void warning(const SAXParseException& exception);
00024 void error(const SAXParseException& exception);
00025 void fatalError(const SAXParseException& exception);
00026 void resetErrors();
00027
00028 int getWarningCount() const {return m_nWarning;}
00029 int getErrorCount() const {return m_nError;}
00030 int getFatalCount() const {return m_nFatal;}
00031
00032 private:
00033 int m_nWarning, m_nError, m_nFatal;
00034 std::ostream& m_errOut;
00035 };
00036
00037
00038 void Process(DOMDocument* doc, char* eltName);
00039
00040
00041
00042 int main(int argc, char* argv[]) {
00043
00044 std::string infile;
00045 if (argc < 2) {
00046 infile=std::string("/u/ey/jrb/dev500/vanilla/xmlBase/v5r1/xml/simpleDoc.xml");
00047 }
00048 else {
00049 infile = std::string(argv[1]);
00050 }
00051
00052 try {
00053 XMLPlatformUtils::Initialize();
00054 }
00055 catch(const XMLException& toCatch)
00056 {
00057 char* charMsg = XMLString::transcode(toCatch.getMessage());
00058 std::string msg = std::string(charMsg);
00059 XMLString::release(&charMsg);
00060
00061 std::cerr << "Error during Xerces-c Initialization.\n"
00062 << " Exception message:" << msg << std::endl;
00063 return 0;
00064 }
00065
00066 const char* inChars = infile.c_str();
00067 XMLCh* xmlchPath = XMLString::transcode(inChars);
00068 XercesDOMParser* parser = new XercesDOMParser();
00069
00070 XmlErrorHandler* errorHandler = new XmlErrorHandler();
00071 parser->setErrorHandler(errorHandler);
00072
00073
00074
00075
00076
00077 parser->setValidationScheme(AbstractDOMParser::Val_Auto);
00078
00079
00080 std::cout << "create entity reference flag has default (true) value" <<
00081 std::endl;
00082 parser->parse(xmlchPath);
00083 DOMDocument* doc = parser->getDocument();
00084 std::cout << "Document successfully parsed" << std::endl;
00085 std::cout << "processing local elements.. " << std::endl;
00086 Process(doc, "const");
00087 std::cout << std::endl << "processing external elements.. " << std::endl;
00088 Process(doc, "extConst");
00089
00090 parser->reset();
00091 parser->setCreateEntityReferenceNodes(false);
00092
00093 std::cout << std::endl << std::endl \
00094 << "create entity reference flag has value false" << std::endl;
00095 parser->parse(xmlchPath);
00096 DOMDocument* expandDoc = parser->getDocument();
00097 std::cout << "Document successfully parsed" << std::endl;
00098 std::cout << "processing local elements.. " << std::endl;
00099 Process(expandDoc, "const");
00100 std::cout << "processing external elements.. " << std::endl;
00101 Process(expandDoc, "extConst");
00102
00103 }
00104
00105 void Process(DOMDocument* doc, char* eltName) {
00106 XMLCh* xmlchEltName = XMLString::transcode(eltName);
00107 XMLCh* xmlchName = XMLString::transcode("name");
00108 XMLCh* xmlchValue = XMLString::transcode("value");
00109 XMLCh* xmlchModified = XMLString::transcode("modified");
00110 if (!doc) {
00111 std::cerr << "invalid document " << std::endl;
00112 return;
00113 }
00114
00115
00116 DOMNodeList* constList = doc->getElementsByTagName(xmlchEltName);
00117 unsigned int nElt = constList->getLength();
00118 for (unsigned int iElt = 0; iElt < nElt; iElt++) {
00119 try {
00120 bool mismatch = false;
00121 DOMNode* item = constList->item(iElt);
00122 DOMElement* itemElt = dynamic_cast<DOMElement *>(item);
00123 DOMElement* byIdElt;
00124 std::cout << std::endl << eltName << " #" << iElt
00125 << " Address as node: "
00126 << item << " and as element: " << itemElt << std::endl;
00127 const XMLCh* xmlchNamevalue = itemElt->getAttribute(xmlchName);
00128 if (XMLString::stringLen(xmlchNamevalue) > 0 ) {
00129 char* namevalue = XMLString::transcode(xmlchNamevalue);
00130 std::cout << "element has name " << namevalue << std::endl;
00131 byIdElt = doc->getElementById(xmlchNamevalue);
00132 std::cout << "Address from getElementById: " << byIdElt << std::endl;
00133 if (byIdElt != itemElt) {
00134 mismatch = true;
00135 std::cout << "**** Address mismatch " << std::endl << std::endl;
00136 }
00137 XMLString::release(&namevalue);
00138 }
00139 std::cout << "Modifying value attribute using DOM_Element address" << std::endl;
00140 itemElt->setAttribute(xmlchValue, xmlchModified);
00141 if (mismatch) {
00142 std::cout << "Modifying value attribute using looked-up address"
00143 << std::endl;
00144 byIdElt->setAttribute(xmlchValue, xmlchModified);
00145
00146 }
00147 }
00148 catch (DOMException ex) {
00149 int code = ex.code;
00150 std::cout << "***** Processing failed for element #" << iElt
00151 << " with DOMException, code = "
00152 << code << std::endl << std::endl;
00153 }
00154 }
00155
00156 }
00157
00158
00159
00160
00161
00162 void XmlErrorHandler::warning(const SAXParseException&) {
00163 m_nWarning++;
00164 }
00165
00166 void XmlErrorHandler::error(const SAXParseException& toCatch) {
00167 char* charSyst = XMLString::transcode(toCatch.getSystemId());
00168 std::string systemId(charSyst);
00169 XMLString::release(&charSyst);
00170 char* charMsg = XMLString::transcode(toCatch.getMessage());
00171 std::string msg(charMsg);
00172 XMLString::release(&charMsg);
00173 m_nError++;
00174 std::cerr << "Error at file \"" << systemId
00175 << "\", line " << toCatch.getLineNumber()
00176 << ", column " << toCatch.getColumnNumber()
00177 << "\n Message: " << msg << "\n\n";
00178 }
00179
00180 void XmlErrorHandler::fatalError(const SAXParseException& toCatch) {
00181
00182
00183 char* charMsg = XMLString::transcode(toCatch.getMessage());
00184 std::string msg(charMsg);
00185 XMLString::release(&charMsg);
00186 m_nFatal++;
00187 if (!(toCatch.getSystemId()) ) {
00188 std::cerr << "Fatal XML parse error: no such file "
00189 << "\n Message: " << msg << "\n\n";
00190 }
00191 else {
00192 char* charSyst = XMLString::transcode(toCatch.getSystemId());
00193 std::string systemId(charSyst);
00194 XMLString::release(&charSyst);
00195 std::cerr << "Fatal error at file \""
00196 << systemId
00197 << "\", line " << toCatch.getLineNumber()
00198 << ", column " << toCatch.getColumnNumber()
00199 << "\n Message: " << msg << "\n\n";
00200 }
00201 }
00202 void XmlErrorHandler::resetErrors() {
00203 m_nWarning = m_nError = m_nFatal = 0;
00204 }