Hi Gareth,
//Here is the code that makes the DOM document...
IMessage::FillDoc()
{
DOMImplementation* impl =
DOMImplementationRegistry::getDOMImplementation(L"Core");
m_pDomDocument = impl->createDocument(
0, // root element namespace URI.
WSZ_MSG_ROOT, // "ATDNewsCLSMsg" root element
name
0); // document type object (DTD).
DOMElement* rootElem = m_pDomDocument->getDocumentElement();
DOMElement* msgElem = m_pDomDocument->createElement(WSZ_HEADER);
rootElem->appendChild(msgElem);
msgElem->setAttribute( WSZ_PRODUCTVERSION,
((CWinAppEx*)AfxGetApp())->GetApplicationProductVersion() );
DOMNode* rootElem = m_pDomDocument->getDocumentElement();
DOMElement* typeElem = m_pDomDocument->createElement(WSZ_TYPE);
rootElem->appendChild(typeElem);
DOMText* typeVal = m_pDomDocument->createTextNode( WSZ_MSG_POWERUP );
typeElem->appendChild(typeVal);
}
//Here is the code that converts the DOM document to a stream...
bool IMessage::CreateSeralizedXMLMemoryBuffer()
{
DOMWriter* pDOMWriter = NULL;
XMLFormatTarget* pXMLFormatTarget = NULL;
try
{
// get a serializer, an instance of DOMWriter
// Note: LS stands for Load & Save.
DOMImplementation* pDOMImplementation =
DOMImplementationRegistry::getDOMImplementation(L"LS");
if (!pDOMImplementation) return false;
pDOMWriter =
((DOMImplementationLS*)pDOMImplementation)->createDOMWriter();
if (!pDOMWriter) return false;
// set user specified end of line sequence and output encoding
pDOMWriter->setNewLine(g_MyEOLSequence);
pDOMWriter->setEncoding(WSZ_ENCODING_UNICODE_LE);
// Plug in a format target to receive the resultant
// XML stream from the serializer.
pXMLFormatTarget = new MemBufFormatTarget();
//
// do the serialization through DOMWriter::writeNode();
//
if (!pDOMWriter->writeNode(pXMLFormatTarget, (const
DOMNode&)*m_pDomDocument))
{
delete pXMLFormatTarget;
pXMLFormatTarget = NULL;
delete pDOMWriter;
pDOMWriter = NULL;
return false;
}
delete pDOMWriter;
m_uiBufferLen = ((MemBufFormatTarget*)pXMLFormatTarget)->getLen();
m_pxmlbytBuffer = new XMLByte[m_uiBufferLen + 2];
memcpy( m_pxmlbytBuffer,
(XMLByte*)((MemBufFormatTarget*)pXMLFormatTarget)->getRawBuffer(), m_uiBufferLen );
m_pxmlbytBuffer[m_uiBufferLen] = NULL;
m_pxmlbytBuffer[m_uiBufferLen+1] = NULL;
// For test purposes...it is nice to see this as a character (Unicode)
buffer.
XMLCh* pxmlchBuffer = (XMLCh*)m_pxmlbytBuffer;
delete pXMLFormatTarget;
pXMLFormatTarget = NULL;
return true;
}
catch(DOMException e)
{
if (pDOMWriter)
{
delete pDOMWriter;
pDOMWriter = NULL;
}
if (pXMLFormatTarget)
{
delete pXMLFormatTarget;
pXMLFormatTarget = NULL;
}
return false;
}
}
// This code takes the stream and makes a DOM Document...
DOMDocument* IMessage::BuildMsg( XMLByte* szXMLStream, unsigned int uiXMLStreamLen )
{
// CDOMInputSourceByteStream class defined below...
CDOMInputSourceByteStream domInputSource( szXMLStream, uiXMLStreamLen );
DOMImplementation* pDOMImplementation =
DOMImplementationRegistry::getDOMImplementation(L"LS");
if (!pDOMImplementation) return NULL;
DOMBuilder* pDOMBuilder =
((DOMImplementationLS*)pDOMImplementation)->createDOMBuilder(DOMImplementationLS::MODE_SYNCHRONOUS,
0);
if (!pDOMBuilder) return NULL;
DOMDocument* pDomDocument = NULL;
DOMDocument* pDomDocumentCopy = NULL;
try
{
pDomDocument = pDOMBuilder->parse( domInputSource );
pDomDocumentCopy = (DOMDocument*)pDomDocument->cloneNode(true);
pDOMBuilder->release();
}
catch (...)
{
return NULL;
}
return pDomDocumentCopy;
}
// Globals and classes used above...
static const XMLCh* g_MyEOLSequence = 0;
static const XMLCh* g_MemBufId = L"ATDNewsXMLStreamID";
class CDOMInputSourceByteStream : public DOMInputSource
{
public:
CDOMInputSourceByteStream( XMLByte* pxmlbytStream, unsigned int uiStreamLen )
{
m_pxmlchBaseURI = NULL;
m_pxmlchSystemId = NULL;
m_pxmlchEncoding = NULL;
m_pxmlchPublicId = NULL;
m_bIssueFatalErrorIfNotFound = true;
m_pxmlbytStream = pxmlbytStream;
m_uiStreamLen = uiStreamLen;
}
virtual BinInputStream* makeStream() const
{
BinInputStream* pBinInputStream = new BinMemInputStream(
m_pxmlbytStream,
m_uiStreamLen,
BinMemInputStream::BufOpt_Reference );
return pBinInputStream;
}
virtual void setEncoding (const XMLCh *const encodingStr)
{
m_pxmlchEncoding = (XMLCh*)encodingStr;
}
virtual void setPublicId (const XMLCh *const publicId)
{
m_pxmlchPublicId = (XMLCh*)publicId;
}
virtual void setSystemId (const XMLCh *const systemId)
{
m_pxmlchSystemId = (XMLCh*)systemId;
}
virtual void setBaseURI (const XMLCh *const baseURI)
{
m_pxmlchBaseURI = (XMLCh*)baseURI;
}
virtual void setIssueFatalErrorIfNotFound (const bool flag)
{
m_bIssueFatalErrorIfNotFound = (XMLCh*)flag;
}
virtual const bool getIssueFatalErrorIfNotFound() const
{
return m_bIssueFatalErrorIfNotFound;
}
virtual void release ()
{
}
virtual const XMLCh* getEncoding() const
{
return m_pxmlchEncoding;
}
virtual const XMLCh* getPublicId() const
{
return m_pxmlchPublicId;
}
virtual const XMLCh* getSystemId() const
{
return m_pxmlchSystemId;
}
virtual const XMLCh* getBaseURI() const
{
return m_pxmlchBaseURI;
}
private:
XMLCh* m_pxmlchBaseURI;
XMLCh* m_pxmlchSystemId;
XMLCh* m_pxmlchPublicId;
XMLCh* m_pxmlchEncoding;
bool m_bIssueFatalErrorIfNotFound;
XMLByte* m_pxmlbytStream;
unsigned int m_uiStreamLen;
};
I would expect the Document I started with and the Document I recreate would be the
same(equivalent). My DOMDocument is contained in a IMessage object. The IMessage
class has an operator== like...
bool IMessage::operator==(const IMessage& rhs ) const
{
if( m_pDomDocument)
{
if( !rhs.m_pDomDocument)
return false;
if (!(m_pDomDocument->isEqualNode((const DOMNode*)rhs.m_pDomDocument)))
return false;
}
else if( rhs.m_pDomDocument)
return false;
}
The ...isEqualNode fails when it gets to checking the localName. It is null in one
object and set to a string (I forget the value) in the other.
Any help would be greatly appreciated.
-dh
-----Original Message-----
From: Gareth Reakes [mailto:[EMAIL PROTECTED]]
Sent: Tuesday, October 01, 2002 4:01 AM
To: [EMAIL PROTECTED]
Subject: Re: Serialize and unserialize DOMDocument over socket
Hi,
post your code and Ill take a look.
Gareth
On Mon, 30 Sep 2002, David Hoffer wrote:
> I am trying to create rather simple DOM documents and send them over
> sockets, I then repackage the socket stream, on the receiving end, into DOM
> documents.
>
> I would expect the documents to be the same, i.e. isEqualNode would return
> true. However, it is failing at least because the LocalName is not the
> same.
>
> Can someone help me with this? Why does the localName not match? I
> understand this might be a level 1 vs. 2 issue but what do I do about that?
> Is there some code where others have did something similar?
>
> -dh
>
>
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: [EMAIL PROTECTED]
> For additional commands, e-mail: [EMAIL PROTECTED]
>
>
--
Gareth Reakes, Head of Product Development
DecisionSoft Ltd. http://www.decisionsoft.com
Office: +44 (0) 1865 203192
---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
