|
1) I wonder if somebody could email me a
working version of DOMSerializer(both DOMSerializer.cpp and DOMSerializer.hpp).
I am using Microsoft Visual Studio 6.0. There is something wrong with the
files which are available for download. I can not compile them. I beleive
the errors were caused by developer using some other IDE . Code has
unusual characters.
2) I am working on a project (see below) which
requires for me to convert a complete DOM_Document with DTD header into a
CString. I removed main method from DOMPrint and included the cpp
file into my project. It prints out the entire Document to the console just
the way I needs it to be in a CString. How can I generate a
CString by using the Serializer? ( if it ever compiles) CString will
be used for a Web Request.
Note: I am a Java Developer who is trying to rework
Java code into C++, so please explain in a plain language. Or provide a little
sample, if possible.
Here is my code:
/**
* Sample.cpp * This app is supposed to generate a properly formatted XML Document */ ///
// Includes /// #include "stdafx.h"
#include <xercesc/util/PlatformUtils.hpp> #include <xercesc/util/XMLString.hpp> #include <xercesc/dom/DOM.hpp> #include <xercesc/dom/DOM_NODE.hpp> #include <iostream.h> #include<fstream.h> #include "StringWriter.cpp" /**
* Main Method */ int main(int argc, char* argv[]) { /**
* Initialize Xml Utilities */ try
{ XMLPlatformUtils::Initialize(); } catch(const XMLException&
toCatch)
{ char *pMsg = XMLString::transcode(toCatch.getMessage()); cerr << "Error during Xerces-c Initialization.\n" << " Exception message:" << pMsg; delete [] pMsg; } DOMPrintFormatTarget* formatTarget; try { DOM_DOMImplementation impl;
DOM_DocumentType dt=impl.createDocumentType("pp.request","-//IMALL//DTD PUREPAYMENTS 1.0//EN","http://www.purepayments.com/dtd/purepayments.dtd"); DOM_Document doc = impl.createDocument( "-//IMALL//DTD PUREPAYMENTS 1.0//EN" , // root element namespace URI. "pp.request",// root element name dt); // document type object (DTD). doc.createXMLDecl("","",false); DOM_Element rootElement =
doc.getDocumentElement();
rootElement.setAttribute("merchant","1001"); rootElement.setAttribute("password","password"); DOM_Element authElement =
doc.createElement("pp.auth");
authElement.setAttribute("ordernumber","10000"); authElement.setAttribute("shippingcost","0.0USD"); authElement.setAttribute("taxamount","0.0USD"); rootElement.appendChild(authElement); DOM_Element
ccElement=doc.createElement("pp.creditcard");
ccElement.setAttribute("number","4111111111111111"); ccElement.setAttribute("expiration","12/05"); authElement.appendChild(ccElement); DOM_Element shipAddrElement=doc.createElement("pp.address"); shipAddrElement.setAttribute("type","shipping");
shipAddrElement.setAttribute("fullname","Test Test");
shipAddrElement.setAttribute("address1","555 Smart Street"); shipAddrElement.setAttribute("address2",""); shipAddrElement.setAttribute("city","Magalia"); shipAddrElement.setAttribute("state","CA"); shipAddrElement.setAttribute("zip","95954"); shipAddrElement.setAttribute("country","US"); authElement.appendChild(shipAddrElement); DOM_Element
lineItemElement=doc.createElement("pp.lineitem");
lineItemElement.setAttribute("sku","sku_1"); lineItemElement.setAttribute("description","Good Product"); lineItemElement.setAttribute("quantity","1"); lineItemElement.setAttribute("taxrate","1"); lineItemElement.setAttribute("unitprice","11.00USD"); authElement.appendChild(lineItemElement); formatTarget = new DOMPrintFormatTarget(); if (gEncodingName ==
0)
{ DOMString encNameStr("UTF-8"); DOM_Node aNode = doc.getFirstChild(); if (aNode.getNodeType() == DOM_Node::XML_DECL_NODE) { DOMString aStr = ((DOM_XMLDecl &)aNode).getEncoding(); if (aStr != "") { encNameStr = aStr; } } unsigned int lent = encNameStr.length(); gEncodingName = new XMLCh[lent + 1]; XMLString::copyNString(gEncodingName, encNameStr.rawBuffer(), lent); gEncodingName[lent] = 0; }
try
{ gFormatter = new XMLFormatter(gEncodingName, formatTarget, XMLFormatter::NoEscapes, gUnRepFlags); cout << doc; *gFormatter << chLF; // add linefeed in requested output encoding cout << flush; } catch (XMLException& e) { cerr << "An error occurred during creation of output transcoder. Msg is:" << endl << DOMString(e.getMessage()) << endl; } }
catch (const XMLException& e)
{ cerr << "An error occured during parsing\n Message: " << DOMString(e.getMessage()) << endl; } catch (const DOM_DOMException& e) { cerr << "A DOM error occured during parsing\n DOMException code: " << e.code << endl; } catch (...)
{ cerr << "An error occured during parsing\n " << endl; } delete formatTarget; delete gFormatter; /**
* Kill memory leaks */ XMLPlatformUtils::Terminate(); return 0;
} /**
* StringWriter.cpp
* This code is DOMPrint.cpp w/out Main method
*/
//
---------------------------------------------------------------------------
// Includes // --------------------------------------------------------------------------- #include <xercesc/util/PlatformUtils.hpp> #include <xercesc/util/XMLString.hpp> #include <xercesc/util/XMLUniDefs.hpp> #include <xercesc/framework/XMLFormatter.hpp> #include <xercesc/util/TranscodingException.hpp> #include <xercesc/dom/DOM_DOMException.hpp> #include <xercesc/parsers/DOMParser.hpp>
#include <xercesc/dom/DOM.hpp> #include "DOMTreeErrorReporter.hpp" #include <string.h> //
---------------------------------------------------------------------------
// Local const data // // Note: This is the 'safe' way to do these strings. If you compiler supports // L"" style strings, and portability is not a concern, you can use // those types constants directly. // --------------------------------------------------------------------------- static const XMLCh gEndElement[] = { chOpenAngle, chForwardSlash, chNull }; static const XMLCh gEndPI[] = { chQuestion, chCloseAngle, chNull}; static const XMLCh gStartPI[] = { chOpenAngle, chQuestion, chNull }; static const XMLCh gXMLDecl1[] = { chOpenAngle, chQuestion, chLatin_x, chLatin_m, chLatin_l , chSpace, chLatin_v, chLatin_e, chLatin_r, chLatin_s, chLatin_i , chLatin_o, chLatin_n, chEqual, chDoubleQuote, chNull }; static const XMLCh gXMLDecl2[] = { chDoubleQuote, chSpace, chLatin_e, chLatin_n, chLatin_c , chLatin_o, chLatin_d, chLatin_i, chLatin_n, chLatin_g, chEqual , chDoubleQuote, chNull }; static const XMLCh gXMLDecl3[] = { chDoubleQuote, chSpace, chLatin_s, chLatin_t, chLatin_a , chLatin_n, chLatin_d, chLatin_a, chLatin_l, chLatin_o , chLatin_n, chLatin_e, chEqual, chDoubleQuote, chNull }; static const XMLCh gXMLDecl4[] = { chDoubleQuote, chQuestion, chCloseAngle , chLF, chNull }; static const XMLCh gStartCDATA[]
=
{ chOpenAngle, chBang, chOpenSquare, chLatin_C, chLatin_D, chLatin_A, chLatin_T, chLatin_A, chOpenSquare, chNull }; static const XMLCh gEndCDATA[] =
{ chCloseSquare, chCloseSquare, chCloseAngle, chNull }; static const XMLCh gStartComment[] = { chOpenAngle, chBang, chDash, chDash, chNull }; static const XMLCh gEndComment[] =
{ chDash, chDash, chCloseAngle, chNull }; static const XMLCh gStartDoctype[] =
{ chOpenAngle, chBang, chLatin_D, chLatin_O, chLatin_C, chLatin_T, chLatin_Y, chLatin_P, chLatin_E, chSpace, chNull }; static const XMLCh gPublic[] = { chLatin_P, chLatin_U, chLatin_B, chLatin_L, chLatin_I, chLatin_C, chSpace, chDoubleQuote, chNull }; static const XMLCh gSystem[] = { chLatin_S, chLatin_Y, chLatin_S, chLatin_T, chLatin_E, chLatin_M, chSpace, chDoubleQuote, chNull }; static const XMLCh gStartEntity[] = { chOpenAngle, chBang, chLatin_E, chLatin_N, chLatin_T, chLatin_I, chLatin_T, chLatin_Y, chSpace, chNull }; static const XMLCh gNotation[] = { chLatin_N, chLatin_D, chLatin_A, chLatin_T, chLatin_A, chSpace, chDoubleQuote, chNull }; //
---------------------------------------------------------------------------
// Local classes // --------------------------------------------------------------------------- class DOMPrintFormatTarget : public
XMLFormatTarget
{ public: DOMPrintFormatTarget() {}; ~DOMPrintFormatTarget() {}; //
-----------------------------------------------------------------------
// Implementations of the format target interface // ----------------------------------------------------------------------- void writeChars(const XMLByte* const
toWrite,
const unsigned int count, XMLFormatter * const formatter) { // Surprisingly, Solaris was the only platform on which // required the char* cast to print out the string correctly. // Without the cast, it was printing the pointer value in hex. // Quite annoying, considering every other platform printed // the string with the explicit cast to char* below. cout.write((char *) toWrite, (int) count); }; private:
// ----------------------------------------------------------------------- // Unimplemented methods. // ----------------------------------------------------------------------- DOMPrintFormatTarget(const DOMPrintFormatTarget& other); void operator=(const DOMPrintFormatTarget& rhs); }; //
---------------------------------------------------------------------------
// Local data // // gXmlFile // The path to the file to parser. Set via command line. // // gDoNamespaces // Indicates whether namespace processing should be done. // // gDoSchema // Indicates whether schema processing should be done. // // gSchemaFullChecking // Indicates whether full schema constraint checking should be done. // // gDoCreate // Indicates whether entity reference nodes needs to be created or not // Defaults to false // // gEncodingName // The encoding we are to output in. If not set on the command line, // then it is defaults to the encoding of the input XML file. // // gValScheme // Indicates what validation scheme to use. It defaults to 'auto', but // can be set via the -v= command. // // --------------------------------------------------------------------------- static char* gXmlFile = 0; static bool gDoNamespaces = false; static bool gDoSchema = false; static bool gSchemaFullChecking = false; static bool gDoCreate = false; static XMLCh* gEncodingName = 0; static XMLFormatter::UnRepFlags gUnRepFlags = XMLFormatter::UnRep_CharRef; static DOMParser::ValSchemes gValScheme = DOMParser::Val_Never; static XMLFormatter* gFormatter = 0; //
---------------------------------------------------------------------------
// Forward references // --------------------------------------------------------------------------- ostream& operator<<(ostream& target, const DOMString& toWrite); ostream& operator<<(ostream& target, DOM_Node& toWrite); XMLFormatter& operator<< (XMLFormatter& strm, const DOMString& s); //
---------------------------------------------------------------------------
// ostream << DOM_Node // // Stream out a DOM node, and, recursively, all of its children. This // function is the heart of writing a DOM tree out as XML source. Give it // a document node and it will do the whole thing. // --------------------------------------------------------------------------- ostream& operator<<(ostream& target, DOM_Node& toWrite) { // Get the name and value out for convenience DOMString nodeName = toWrite.getNodeName(); DOMString nodeValue = toWrite.getNodeValue(); unsigned long lent = nodeValue.length(); switch (toWrite.getNodeType())
{ case DOM_Node::TEXT_NODE: { gFormatter->formatBuf(nodeValue.rawBuffer(), lent, XMLFormatter::CharEscapes); break; } case DOM_Node::PROCESSING_INSTRUCTION_NODE : { *gFormatter << XMLFormatter::NoEscapes << gStartPI << nodeName; if (lent > 0) { *gFormatter << chSpace << nodeValue; } *gFormatter << XMLFormatter::NoEscapes << gEndPI; break; } case DOM_Node::DOCUMENT_NODE : { DOM_Node
child =
toWrite.getFirstChild();
while( child != 0) { target << child; // add linefeed in requested output encoding *gFormatter << chLF; target << flush; child = child.getNextSibling(); } break; } case DOM_Node::ELEMENT_NODE : { // The name has to be representable without any escapes *gFormatter << XMLFormatter::NoEscapes << chOpenAngle << nodeName; //
Output the element start tag.
//
Output any attributes on this
element
DOM_NamedNodeMap attributes = toWrite.getAttributes(); int attrCount = attributes.getLength(); for (int i = 0; i < attrCount; i++) { DOM_Node attribute = attributes.item(i);
//
// Again the name has to be completely representable. But the // attribute can have refs and requires the attribute style // escaping. // *gFormatter << XMLFormatter::NoEscapes << chSpace << attribute.getNodeName() << chEqual << chDoubleQuote << XMLFormatter::AttrEscapes << attribute.getNodeValue() << XMLFormatter::NoEscapes << chDoubleQuote; }
//
// Test for the presence of children, which includes both // text content and nested elements. // DOM_Node child = toWrite.getFirstChild(); if (child != 0) { // There are children. Close start-tag, and output children. // No escapes are legal here *gFormatter << XMLFormatter::NoEscapes << chCloseAngle;
while( child !=
0)
{ target << child; child = child.getNextSibling(); }
//
// Done with children. Output the end tag. // *gFormatter << XMLFormatter::NoEscapes << gEndElement << nodeName << chCloseAngle; } else { // // There were no children. Output the short form close of // the element start tag, making it an empty-element tag. // *gFormatter << XMLFormatter::NoEscapes << chForwardSlash << chCloseAngle; } break; } case DOM_Node::ENTITY_REFERENCE_NODE: { DOM_Node child; #if 0 for (child = toWrite.getFirstChild(); child != 0; child = child.getNextSibling()) { target << child; } #else // // Instead of printing the refernece tree // we'd output the actual text as it appeared in the xml file. // This would be the case when -e option was chosen // *gFormatter << XMLFormatter::NoEscapes << chAmpersand << nodeName << chSemiColon; #endif break; } case DOM_Node::CDATA_SECTION_NODE: { *gFormatter << XMLFormatter::NoEscapes << gStartCDATA << nodeValue << gEndCDATA; break; } case DOM_Node::COMMENT_NODE: { *gFormatter << XMLFormatter::NoEscapes << gStartComment << nodeValue << gEndComment; break; } case DOM_Node::DOCUMENT_TYPE_NODE: { DOM_DocumentType doctype = (DOM_DocumentType &)toWrite;;
*gFormatter << XMLFormatter::NoEscapes <<
gStartDoctype
<< nodeName;
DOMString id =
doctype.getPublicId();
if (id != 0) { *gFormatter << XMLFormatter::NoEscapes << chSpace << gPublic << id << chDoubleQuote; id = doctype.getSystemId(); if (id != 0) { *gFormatter << XMLFormatter::NoEscapes << chSpace << chDoubleQuote << id << chDoubleQuote; } } else { id = doctype.getSystemId(); if (id != 0) { *gFormatter << XMLFormatter::NoEscapes << chSpace << gSystem << id << chDoubleQuote; } } id =
doctype.getInternalSubset();
if (id !=0) *gFormatter << XMLFormatter::NoEscapes << chOpenSquare << id << chCloseSquare;
*gFormatter << XMLFormatter::NoEscapes <<
chCloseAngle;
break; } case DOM_Node::ENTITY_NODE: { *gFormatter << XMLFormatter::NoEscapes << gStartEntity << nodeName;
DOMString id = ((DOM_Entity
&)toWrite).getPublicId();
if (id != 0) *gFormatter << XMLFormatter::NoEscapes << gPublic << id << chDoubleQuote; id =
((DOM_Entity
&)toWrite).getSystemId();
if (id != 0) *gFormatter << XMLFormatter::NoEscapes << gSystem << id << chDoubleQuote; id =
((DOM_Entity
&)toWrite).getNotationName();
if (id != 0) *gFormatter << XMLFormatter::NoEscapes << gNotation << id << chDoubleQuote;
*gFormatter << XMLFormatter::NoEscapes << chCloseAngle <<
chLF;
break;
} case DOM_Node::XML_DECL_NODE: { DOMString str;
*gFormatter << gXMLDecl1 << ((DOM_XMLDecl
&)toWrite).getVersion();
*gFormatter << gXMLDecl2 << gEncodingName;
str =
((DOM_XMLDecl
&)toWrite).getStandalone();
if (str != 0) *gFormatter << gXMLDecl3 << str;
*gFormatter << gXMLDecl4;
break;
} default: cerr << "Unrecognized node type = " << (long)toWrite.getNodeType() << endl; } return target; } //
---------------------------------------------------------------------------
// ostream << DOMString // // Stream out a DOM string. Doing this requires that we first transcode // to char * form in the default code page for the system // --------------------------------------------------------------------------- ostream& operator<< (ostream& target, const DOMString& s) { char *p = s.transcode(); target << p; delete [] p; return target; } XMLFormatter& operator<< (XMLFormatter& strm, const DOMString& s) { unsigned int lent = s.length(); if (lent <= 0)
return strm; XMLCh* buf = new XMLCh[lent +
1];
XMLString::copyNString(buf, s.rawBuffer(), lent); buf[lent] = 0; strm << buf; delete [] buf; return strm; } |
