[prev in list] [next in list] [prev in thread] [next in thread]
List: xerces-c-dev
Subject: Please help me out in this function
From: "Sree Harsha" <sree.harsha.sn () gmail ! com>
Date: 2008-02-25 5:41:18
Message-ID: 4ba3dbf80802242129g5ccbc0c2mbde5e953e99a132b () mail ! gmail ! com
[Download RAW message or body]
/* this function loads an xml and divides the xml into smaller xmls of 4k
size and processes it so that the memory consumption does not increase but
when i parsed a xml file of 380MB size it consumed all the memory and ran
out of memory.. i got a message in the notification area that i had run out
of all the virtual memory...Please look at the code ... I know it is quite
long...but please help me out in this .. i dont know what to release()...
none of the example programs use the
domelement/domnodeiterator/parser object in a loop*/
void load()
throw( std::runtime_error )
{
std::cout<<"in load"<<std::endl;
DWORD dw;
DWORD dwErrorCount=0;
LPDWORD lpFileSize;
HANDLE hSourceFile;
HANDLE hDestFile;
HANDLE hTempFile;
DWORD dwBytesRead=0, dwBytesWritten=0, dwBufSize=BUFSIZE;
char szDestFile[MAX_PATH];
const char *szSourceFile=InXMLFile_.c_str();
char szTempName[MAX_PATH];
char lpPathBuffer[BUFSIZE];
char buffer[BUFSIZE];
char lbuffer[BUFSIZE];
char lEndLineBuffer[BUFSIZE];
int i=0,j=0,k=0;
int found=0;
int EventType;
char szLineEndings[3];
szLineEndings[0]=13;
szLineEndings[1]=10;
szLineEndings[2]=0;
char szStartLine[42]="<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
strcat_s(szStartLine,sizeof(szStartLine),szLineEndings);
char szEventlistTag[14]="<eventlist>";
strcat_s(szEventlistTag,sizeof(szEventlistTag),szLineEndings);
char szEventlistEndTag[]="</eventlist>";
xercesc::DOMDocumentType* outXmlDoctype = NULL;
xercesc::DOMDocument* outXmlDoc = NULL;
xercesc::DOMNode *pNode = NULL;
xercesc::DOMImplementation *pImplement = NULL;
// these two are needed to display DOM output.
xercesc::DOMWriter *pSerializer = NULL;
xercesc::XMLFormatTarget *pTarget = new
LocalFileFormatTarget(dsOutXMLFile_.asXMLString());;
// get a serializer, an instance of DOMWriter (the "LS" stands for
load-save).
pImplement =
DOMImplementationRegistry::getDOMImplementation(XercesString("LS"));
pSerializer = ( (DOMImplementationLS*)pImplement )->createDOMWriter();
// set user specified end of line sequence and output encoding
pSerializer->setNewLine( XercesString("\n") );
// set feature if the serializer supports the feature/mode
if ( pSerializer->canSetFeature(XMLUni::fgDOMWRTSplitCdataSections, false)
)
pSerializer->setFeature(XMLUni::fgDOMWRTSplitCdataSections, false);
if ( pSerializer->canSetFeature(XMLUni::fgDOMWRTDiscardDefaultContent,
false) )
pSerializer->setFeature(XMLUni::fgDOMWRTDiscardDefaultContent, false);
if ( pSerializer->canSetFeature(XMLUni::fgDOMWRTFormatPrettyPrint, false)
)
pSerializer->setFeature(XMLUni::fgDOMWRTFormatPrettyPrint, false);
if ( pSerializer->canSetFeature(XMLUni::fgDOMWRTBOM, false) )
pSerializer->setFeature(XMLUni::fgDOMWRTBOM, false);
// create a document
outXmlDoctype = pImplement->createDocumentType(XercesString("LS"
),NULL,NULL);
//creates a root tag called <Product>
outXmlDoc = pImplement->createDocument( NULL, XercesString("Product"),NULL
);
if (outXmlDoc)
{
// output related nodes are prefixed with "svg"
// to distinguish them from input nodes.
outXmlDoc->setEncoding( XercesString("UTF-8") );
outXmlDoc->setStandalone(true);
outXmlDoc->setVersion( XercesString("1.0") );
DOMElement *pRoot = outXmlDoc->getDocumentElement();
DOMAttr* attrName = outXmlDoc->createAttribute( XercesString("name")
);
attrName->setValue( XercesString("Name") );
pRoot->setAttributeNode(attrName);
DOMAttr* attrVersion= outXmlDoc->createAttribute( XercesString("version")
);
attrVersion->setValue( XercesString("Version") );
pRoot->setAttributeNode(attrVersion);
// Create a root element
DOMElement* pFiles = outXmlDoc->createElement(XercesString("Files") );
pRoot->appendChild(pFiles);
DOMElement* pAddedFiles=outXmlDoc->createElement(XercesString("Added"));
pFiles->appendChild(pAddedFiles);
DOMElement*
pUpdatedFiles=outXmlDoc->createElement(XercesString("Updated"));
pFiles->appendChild(pUpdatedFiles);
DOMElement*
pDeletedFiles=outXmlDoc->createElement(XercesString("Deleted"));
pFiles->appendChild(pDeletedFiles);
DOMElement* pDirs = outXmlDoc->createElement( XercesString("Dirs") );
pRoot->appendChild(pDirs);
DOMElement* pAddedDirs = outXmlDoc->createElement( XercesString("Added")
);
pDirs->appendChild(pAddedDirs);
DOMElement* pUpdatedDirs = outXmlDoc->createElement(
XercesString("Updated") );
pDirs->appendChild(pUpdatedDirs);
DOMElement* pDeletedDirs = outXmlDoc->createElement(
XercesString("Deleted") );
pDirs->appendChild(pDeletedDirs);
DOMElement* pRegKey = outXmlDoc->createElement( XercesString("RegistryKey")
);
pRoot->appendChild(pRegKey);
DOMElement* pAddedRegKey = outXmlDoc->createElement(
XercesString("Added") );
pRegKey->appendChild(pAddedRegKey);
DOMElement* pUpdatedRegKey = outXmlDoc->createElement(
XercesString("Updated") );
pRegKey->appendChild(pUpdatedRegKey);
DOMElement* pDeletedRegKey = outXmlDoc->createElement(
XercesString("Deleted") );
pRegKey->appendChild(pDeletedRegKey);
DOMElement* pRegValue = outXmlDoc->createElement(
XercesString("RegistryValue") );
pRoot->appendChild(pRegValue);
DOMElement* pAddedRegValue = outXmlDoc->createElement(
XercesString("Added") );
pRegValue->appendChild(pAddedRegValue);
DOMElement* pUpdatedRegValue = outXmlDoc->createElement(
XercesString("Updated") );
pRegValue->appendChild(pUpdatedRegValue);
DOMElement* pDeletedRegValue = outXmlDoc->createElement(
XercesString("Deleted") );
pRegValue->appendChild(pDeletedRegValue);
DOMElement* pServices = outXmlDoc->createElement( XercesString("Services")
);
pRoot->appendChild(pServices);
DOMElement* pAddedServices = outXmlDoc->createElement(
XercesString("Added") );
pServices->appendChild(pAddedServices);
DOMElement* pUpdatedServices = outXmlDoc->createElement(
XercesString("Updated") );
pServices->appendChild(pUpdatedServices);
DOMElement* pDeletedServices = outXmlDoc->createElement(
XercesString("Deleted") );
pServices->appendChild(pDeletedServices);
parser_.setValidationScheme( xercesc::XercesDOMParser::Val_Never ) ;
parser_.setDoNamespaces( false ) ;
parser_.setDoSchema( false ) ;
parser_.setLoadExternalDTD( false ) ;
hSourceFile = CreateFile(szSourceFile, // file name
GENERIC_READ, // open for reading
FILE_SHARE_READ, // Enables subsequent open
operations on an object to request read access
NULL, // default security
OPEN_EXISTING, // existing file only
FILE_ATTRIBUTE_NORMAL, // normal file
NULL); // no template
if (hSourceFile == INVALID_HANDLE_VALUE)
{
std::cout<<"Error: "<<GetLastError()<<std::endl<<"Could not open source
File"<<std::endl;
return;
}
GetTempPath(dwBufSize, // length of the buffer
lpPathBuffer); // buffer for path
// Create a temporary file.
GetTempFileName(lpPathBuffer, // directory for temp files
"NEW", // temp file name prefix
0, // create unique name
szTempName); // buffer for name
XercesString src(szTempName);
std::cout<<"szTempName: "<<szTempName<<std::endl;
do
{
i=0;
ReadFile(hSourceFile, buffer, BUFSIZE,&dwBytesRead, NULL);
found=0;
do
{
k=GetLine(buffer+i, lbuffer,&i,dwBytesRead);
i+=k;
if(i>dwBytesRead)
{
SetFilePointer(hSourceFile,-k,NULL,FILE_CURRENT);
break;
}
if(strstr(lbuffer,TEXT("<eventlist>")))
{
found=1;
}
}while((i<dwBytesRead)&&(found==0));
}while((dwBytesRead==BUFSIZE)&&(found==0));
SetFilePointer(hSourceFile,-(BUFSIZE-i),NULL,FILE_CURRENT);
do{
{
LocalFileInputSource source(src);
hTempFile = CreateFile((LPTSTR) szTempName, // file name
GENERIC_READ | GENERIC_WRITE, // open for read/write
FILE_SHARE_READ, // Enables subsequent open operations on
an object to request read access
NULL, // default security
CREATE_ALWAYS, // overwrite existing file
FILE_ATTRIBUTE_NORMAL, // normal file
NULL); // no template
if (hTempFile == INVALID_HANDLE_VALUE)
{
std::cout<<"Error: "<<GetLastError()<<std::endl<<"Could not open temp
File"<<std::endl;
return;
}
WriteFile(hTempFile,szStartLine,sizeof(szStartLine)-2,&dwBytesWritten,NULL);
WriteFile(hTempFile,szEventlistTag,sizeof(szEventlistTag)-1,&dwBytesWritten,NULL);
i=0;
ReadFile(hSourceFile, buffer, BUFSIZE,&dwBytesRead, NULL);
do
{
j=0;
k=GetCurEvent(buffer+i,lbuffer,&j,&i,&dwBytesRead);
i+=k;
if((i>dwBytesRead)||(j==1))
{
k=dwBytesRead-(i-k);
SetFilePointer(hSourceFile,-k,NULL,FILE_CURRENT);
break;
}
if(j==-1)
{
break;
}
WriteFile(hTempFile,lbuffer,k,&dwBytesWritten,NULL);
}while(i<BUFSIZE);
WriteFile(hTempFile,szEventlistEndTag,sizeof(szEventlistEndTag)-1,&dwBytesWritten,NULL);
CloseHandle(hTempFile);
//Event Handle functions here...
//
try{
parser_.parse(source);
dwErrorCount+=parser_.getErrorCount();
//std::cout<<"parser_getErrorCount()
"<<parser_.getErrorCount()<<std::endl;
if(!(parser_.getErrorCount()))
{
xercesc::DOMDocument* xmlDoc = parser_.getDocument() ;
xercesc::DOMElement* elementConfig = xmlDoc->getDocumentElement() ;
if( NULL == elementConfig ){
throw( std::runtime_error( "empty XML document" ) ) ;
}
xercesc::DOMNodeList* children = elementConfig->getElementsByTagName
(tags_.TAG_event.asXMLString());
const XMLSize_t nodeCount = children->getLength() ;
for( XMLSize_t ix = 0 ; ix < nodeCount ; ++ix ){
xercesc::DOMNode* currentNode = children->item( ix ) ;
if( NULL == currentNode ){
// null node...
continue ;
}
if( xercesc::DOMNode::ELEMENT_NODE != currentNode->getNodeType() ){
// not an element node -> not of interest here
continue ;
}
xercesc::DOMElement* currentElement = (xercesc::DOMElement*)(
currentNode ) ;
EventType=handleEvent( currentElement ) ;
switch(EventType)
{
case 10:
{
DOMNodeIterator* iterator =
outXmlDoc->createNodeIterator(pAddedFiles, DOMNodeFilter::SHOW_TEXT, NULL,
true);
DOMNode* pCurrent = NULL;
// use the tree walker to print out the text nodes.
for ( pCurrent = iterator->nextNode();pCurrent != 0; pCurrent =
iterator->nextNode())
{
char *strValue = XMLString::transcode( pCurrent->getNodeValue() );
if(!strcmp(strValue,Path_.c_str()))
{
EventType=0;
}
//XMLString::release(&strValue);
}
if(EventType)
{
DOMElement* pPath = outXmlDoc->createElement( XercesString("Path")
);
pAddedFiles->appendChild(pPath);
DOMText* pPathnode=outXmlDoc->createTextNode(
XercesString(Path_.c_str()) );
pPath->appendChild(pPathnode);
}
iterator->release();
break;
}//case 10;
case 11:
{
DOMNodeIterator* iterator=
outXmlDoc->createNodeIterator(pAddedFiles, DOMNodeFilter::SHOW_TEXT, NULL,
true);
DOMNodeIterator* uiterator =
outXmlDoc->createNodeIterator(pUpdatedFiles, DOMNodeFilter::SHOW_TEXT, NULL,
true);
DOMNode* pCurrent = NULL;
// use the tree walker to print out the text nodes.
for ( pCurrent = iterator->nextNode();pCurrent != 0; pCurrent =
iterator->nextNode())
{
char *strValue = XMLString::transcode( pCurrent->getNodeValue() );
if(!strcmp(strValue,Path_.c_str()))
{
EventType=0;
}
//XMLString::release(&strValue);
}
if(EventType){
for ( pCurrent = uiterator->nextNode();pCurrent != 0; pCurrent =
uiterator->nextNode())
{
char *strValue = XMLString::transcode( pCurrent->getNodeValue() );
if(!strcmp(strValue,Path_.c_str()))
{
EventType=0;
}
//XMLString::release(&strValue);
}}
if(EventType)
{
//XMLString::release(&strValue);
DOMElement* pPath = outXmlDoc->createElement( XercesString("Path")
);
pUpdatedFiles->appendChild(pPath);
DOMText* pPathnode=outXmlDoc->createTextNode(
XercesString(Path_.c_str()) );
pPath->appendChild(pPathnode);
}
uiterator->release();
iterator->release();
break;
}// case(11)...
case(12):
{
DOMElement* pPath = outXmlDoc->createElement( XercesString("Path")
);
pDeletedFiles->appendChild(pPath);
DOMText* pPathnode=outXmlDoc->createTextNode(
XercesString(Path_.c_str()) );
pPath->appendChild(pPathnode);
break;
}
case (20):
{
DOMNodeIterator* iterator =
outXmlDoc->createNodeIterator(pAddedDirs, DOMNodeFilter::SHOW_TEXT, NULL,
true);
DOMNode* pCurrent = NULL;
// use the tree walker to print out the text nodes.
for ( pCurrent = iterator->nextNode();pCurrent != 0; pCurrent =
iterator->nextNode())
{
char *strValue = XMLString::transcode( pCurrent->getNodeValue() );
if(!strcmp(strValue,Path_.c_str()))
{
EventType=0;
}
//XMLString::release(&strValue);
}
if(EventType)
{
DOMElement* pPath = outXmlDoc->createElement( XercesString("Path")
);
pAddedDirs->appendChild(pPath);
DOMText* pPathnode=outXmlDoc->createTextNode(
XercesString(Path_.c_str()) );
pPath->appendChild(pPathnode);
}
iterator->release();
break;
}
case (21):
{
break;
}
case (22):
{
DOMElement* pPath = outXmlDoc->createElement( XercesString("Path")
);
pDeletedDirs->appendChild(pPath);
DOMText* pPathnode=outXmlDoc->createTextNode(
XercesString(Path_.c_str()) );
pPath->appendChild(pPathnode);
break;
}
case (30):
{
DOMNodeIterator* iterator =
outXmlDoc->createNodeIterator(pAddedRegKey, DOMNodeFilter::SHOW_TEXT, NULL,
true);
DOMNode* pCurrent = NULL;
// use the tree walker to print out the text nodes.
for ( pCurrent = iterator->nextNode();pCurrent != 0; pCurrent =
iterator->nextNode())
{
char *strValue = XMLString::transcode( pCurrent->getNodeValue() );
if(!strcmp(strValue,Path_.c_str()))
{
EventType=0;
}
//XMLString::release(&strValue);
}
if(EventType)
{
DOMElement* pPath = outXmlDoc->createElement( XercesString("Path")
);
pAddedRegKey->appendChild(pPath);
DOMText* pPathnode=outXmlDoc->createTextNode(
XercesString(Path_.c_str()) );
pPath->appendChild(pPathnode);
}
iterator->release();
break;
}
}//end of switch
}//for loop..
xmlDoc->release();
//std::cin>>dwBytesWritten;
}
}
catch( xercesc::XMLException& e ){
// believe it or not, XMLException is not
// a parent class of DOMException
char* message = xercesc::XMLString::transcode( e.getMessage() ) ;
std::ostringstream buf ;
buf << "Error parsing file: "
<< message
<< std::flush;
xercesc::XMLString::release( &message ) ;
throw( std::runtime_error( buf.str() ) ) ;
}
catch( const xercesc::DOMException& e ){
char* message = xercesc::XMLString::transcode( e.getMessage() ) ;
std::ostringstream buf ;
buf << "Encountered DOM Exception: "
<< message<< std::flush;
xercesc::XMLString::release( &message ) ;
throw( std::runtime_error( buf.str() ) ) ;
}
if((j==-1))
{
break;
}
}
DOMRange* range = outXmlDoc->createRange();
range->release();
parser_.resetDocument();
}while(dwBytesRead==BUFSIZE);
//Here should be write file...
pSerializer->writeNode(pTarget, *outXmlDoc);
if(dwErrorCount)
{
std::cout<<"Number of errors in file = "<<dwErrorCount<<std::endl<<":-(";
}
else
{
std::cout<<"No Errors found in file ;-)"<<std::endl;
std::cout<<"Number of Files Created= "<<CreateFileCount<<std::endl;
std::cout<<"Number of Files Deleted= "<<DeleteFileCount<<std::endl;
std::cout<<"Number of Folders Created= "<<CreateFolderCount<<std::endl;
}
//std::cin>>dwBytesWritten;
}//if (outXmlFile)...end
delete pTarget;
delete pSerializer;
delete outXmlDoc;
delete outXmlDoctype;
DeleteFile(szTempName);
CloseHandle(hSourceFile);
return ;
} // load()
--
Regards
Sree Harsha Vardhana S.N
"When you want something, all the universe conspires in helping you to
achieve it."
[Attachment #3 (text/html)]
<div>/* this function loads an xml and divides the xml into smaller xmls of 4k \
size and processes it so that the memory consumption does not increase but when i \
parsed a xml file of 380MB size it consumed all the memory and ran out of memory.. i \
got a message in the notification area that i had run out of all the virtual \
memory...Please look at the code ... I know it is quite long...but please help \
me out in this .. i dont know what to release()... none of the \
example programs use the domelement/domnodeiterator/parser object in a \
loop*/</div>
<div><br> void load()<br> throw( std::runtime_error \
)<br> {<br> std::cout<<"in \
load"<<std::endl;<br> DWORD \
dw; <br> DWORD \
dwErrorCount=0; <br> LPDWORD \
lpFileSize; <br> HANDLE hSourceFile; <br> \
HANDLE hDestFile; <br> HANDLE \
hTempFile; <br> DWORD dwBytesRead=0, dwBytesWritten=0, \
dwBufSize=BUFSIZE; <br> char \
szDestFile[MAX_PATH]; <br> const char \
*szSourceFile=InXMLFile_.c_str(); <br> char \
szTempName[MAX_PATH]; <br> char \
lpPathBuffer[BUFSIZE]; <br> char \
buffer[BUFSIZE]; <br> char \
lbuffer[BUFSIZE]; <br> char \
lEndLineBuffer[BUFSIZE]; <br> int \
i=0,j=0,k=0; <br> int found=0;<br> int \
EventType; <br> char szLineEndings[3]; <br> \
szLineEndings[0]=13;<br> szLineEndings[1]=10;<br> szLineEndings[2]=0;<br> char \
szStartLine[42]="<?xml version=\"1.0\" \
encoding=\"UTF-8\"?>";<br> strcat_s(szStartLine,sizeof(szStartLine),szLineEndings);<br>
char szEventlistTag[14]="<eventlist>";<br> strcat_s(szEventlistTag,sizeof(szEventlistTag),szLineEndings);<br> char \
szEventlistEndTag[]="</eventlist>"; \
<br> xercesc::DOMDocumentType* outXmlDoctype = NULL;<br> \
xercesc::DOMDocument* outXmlDoc = NULL;<br> xercesc::DOMNode \
*pNode = NULL;<br> xercesc::DOMImplementation *pImplement = \
NULL;<br> <br> // these two are needed to display DOM \
output.<br> xercesc::DOMWriter *pSerializer = NULL; <br> \
xercesc::XMLFormatTarget *pTarget = new \
LocalFileFormatTarget(dsOutXMLFile_.asXMLString());; \
<br> <br> // get a serializer, an instance of DOMWriter (the \
"LS" stands for load-save).<br> pImplement = \
DOMImplementationRegistry::getDOMImplementation(XercesString("LS"));<br> \
pSerializer = ( (DOMImplementationLS*)pImplement \
)->createDOMWriter();<br> <br> // set user specified end of \
line sequence and output encoding<br> pSerializer->setNewLine( \
XercesString("\n") );</div> <p> // set feature if the serializer \
supports the feature/mode<br> if ( \
pSerializer->canSetFeature(XMLUni::fgDOMWRTSplitCdataSections, false) \
)<br> pSerializer->setFeature(XMLUni::fgDOMWRTSplitCdataSections, \
false);<br> <br> if ( \
pSerializer->canSetFeature(XMLUni::fgDOMWRTDiscardDefaultContent, false) \
)<br> pSerializer->setFeature(XMLUni::fgDOMWRTDiscardDefaultContent, \
false);<br> if ( \
pSerializer->canSetFeature(XMLUni::fgDOMWRTFormatPrettyPrint, false) )<br> \
pSerializer->setFeature(XMLUni::fgDOMWRTFormatPrettyPrint, \
false);<br> if ( pSerializer->canSetFeature(XMLUni::fgDOMWRTBOM, false) \
)<br> pSerializer->setFeature(XMLUni::fgDOMWRTBOM, \
false);<br> <br> // create a document<br> \
outXmlDoctype = \
pImplement->createDocumentType(XercesString("LS" \
),NULL,NULL);<br> //creates a root tag called \
<Product><br> outXmlDoc = pImplement->createDocument( NULL, \
XercesString("Product"),NULL );<br> if \
(outXmlDoc)<br> {<br> // output related nodes are \
prefixed with "svg"<br> // to distinguish them from input \
nodes.<br> outXmlDoc->setEncoding( \
XercesString("UTF-8") \
);<br> outXmlDoc->setStandalone(true);<br> \
outXmlDoc->setVersion( XercesString("1.0") \
);<br> DOMElement *pRoot = \
outXmlDoc->getDocumentElement();<br> DOMAttr* \
attrName = outXmlDoc->createAttribute( \
XercesString("name") );<br> attrName->setValue( \
XercesString("Name") \
);<br> pRoot->setAttributeNode(attrName);<br> DOMAttr* \
attrVersion= outXmlDoc->createAttribute( XercesString("version") \
);<br> attrVersion->setValue( XercesString("Version") \
);<br> pRoot->setAttributeNode(attrVersion);<br> // \
Create a root element<br> DOMElement* pFiles = \
outXmlDoc->createElement(XercesString("Files") \
);<br> pRoot->appendChild(pFiles);<br> DOMElement* \
pAddedFiles=outXmlDoc->createElement(XercesString("Added"));<br> \
pFiles->appendChild(pAddedFiles);<br> DOMElement* \
pUpdatedFiles=outXmlDoc->createElement(XercesString("Updated"));<br>  \
; pFiles->appendChild(pUpdatedFiles);<br> DOMElement* \
pDeletedFiles=outXmlDoc->createElement(XercesString("Deleted"));<br> \
pFiles->appendChild(pDeletedFiles);</p> \
<p> DOMElement* pDirs = outXmlDoc->createElement( \
XercesString("Dirs") \
);<br> pRoot->appendChild(pDirs);<br> DOMElement* \
pAddedDirs = outXmlDoc->createElement( XercesString("Added") );<br> \
pDirs->appendChild(pAddedDirs);<br> DOMElement* \
pUpdatedDirs = outXmlDoc->createElement( XercesString("Updated") \
);<br> pDirs->appendChild(pUpdatedDirs);<br> DOMElement* \
pDeletedDirs = outXmlDoc->createElement( XercesString("Deleted") );<br> \
pDirs->appendChild(pDeletedDirs);</p> <p> DOMElement* \
pRegKey = outXmlDoc->createElement( XercesString("RegistryKey") \
);<br> pRoot->appendChild(pRegKey);<br> \
DOMElement* pAddedRegKey = outXmlDoc->createElement( \
XercesString("Added") );<br> \
pRegKey->appendChild(pAddedRegKey);<br> DOMElement* pUpdatedRegKey = \
outXmlDoc->createElement( XercesString("Updated") \
);<br> \
pRegKey->appendChild(pUpdatedRegKey);<br> DOMElement* pDeletedRegKey = \
outXmlDoc->createElement( XercesString("Deleted") );<br> \
pRegKey->appendChild(pDeletedRegKey);</p> <p> DOMElement* \
pRegValue = outXmlDoc->createElement( XercesString("RegistryValue") \
);<br> pRoot->appendChild(pRegValue);<br> \
DOMElement* pAddedRegValue = outXmlDoc->createElement( \
XercesString("Added") );<br> \
pRegValue->appendChild(pAddedRegValue);<br> DOMElement* \
pUpdatedRegValue = outXmlDoc->createElement( XercesString("Updated") \
);<br> \
pRegValue->appendChild(pUpdatedRegValue);<br> DOMElement* \
pDeletedRegValue = outXmlDoc->createElement( XercesString("Deleted") \
);<br> pRegValue->appendChild(pDeletedRegValue);</p>
<p> DOMElement* pServices = outXmlDoc->createElement( \
XercesString("Services") );<br> \
pRoot->appendChild(pServices);<br> DOMElement* \
pAddedServices = outXmlDoc->createElement( XercesString("Added") );<br> \
pServices->appendChild(pAddedServices);<br> DOMElement* \
pUpdatedServices = outXmlDoc->createElement( XercesString("Updated") \
);<br> \
pServices->appendChild(pUpdatedServices);<br> DOMElement* \
pDeletedServices = outXmlDoc->createElement( XercesString("Deleted") \
);<br> \
pServices->appendChild(pDeletedServices); <br> </p> \
<p> parser_.setValidationScheme( xercesc::XercesDOMParser::Val_Never ) \
;<br> parser_.setDoNamespaces( false ) \
;<br> parser_.setDoSchema( false ) \
;<br> parser_.setLoadExternalDTD( false ) \
;<br> <br> hSourceFile = \
CreateFile(szSourceFile, // file name <br> \
\
GENERIC_READ, \
// open for reading <br> \
FILE_SHARE_READ, \
// Enables subsequent open operations on an object to request read \
access<br> \
NULL, \
// default security <br> \
OPEN_EXISTING, \
// existing file only <br> \
FILE_ATTRIBUTE_NORMAL, // \
normal file <br> \
NULL); \
// no template <br> if (hSourceFile == INVALID_HANDLE_VALUE)<br> \
{<br> std::cout<<"Error: \
"<<GetLastError()<<std::endl<<"Could not open source \
File"<<std::endl;<br> return;<br> }<br> GetTempPath(dwBufSize, \
// length of the buffer<br> \
lpPathBuffer); // buffer for path \
<br> // Create a temporary file. \
<br> GetTempFileName(lpPathBuffer, // directory for temp files \
<br> "NEW", \
// temp file name prefix<br> 0, &n \
bsp; \
// create unique name<br> \
szTempName); \
// buffer for name<br> XercesString src(szTempName);<br> </p> \
<p> std::cout<<"szTempName: \
"<<szTempName<<std::endl; </p> \
<p> do<br> {<br> <br> i=0;<br> ReadFile(hSourceFile, \
buffer, BUFSIZE,&dwBytesRead, \
NULL);<br> found=0;<br> do<br> {<br> k=GetLine(buffer+i, \
lbuffer,&i,dwBytesRead);<br> i+=k;<br> if(i>dwBytesRead)<br>
{<br> SetFilePointer(hSourceFile \
,-k,NULL,FILE_CURRENT);<br> break;<br> & \
nbsp;}<br> if(strstr(lbuffer,TEXT("<eventlist>" \
)))<br> {<br> found=1;<br> &n \
bsp; }<br> }while((i<dwBytesRead)&&(found==0));<br>
}while((dwBytesRead==BUFSIZE)&&(found==0));</p>
<p> SetFilePointer(hSourceFile,-(BUFSIZE-i),NULL,FILE_CURRENT);<br> &n \
bsp;<br> do{<br> {<br> LocalFileInputSource \
source(src);<br> hTempFile = CreateFile((LPTSTR) szTempName, \
// file name<br> GENERIC_READ | GENERIC_WRITE, // open for \
read/write <br> FILE_SHARE_READ, \
// Enables subsequent open operations on an object to request read \
access<br> NULL,   \
; \
// default security <br> CREATE_ALWAYS, \
// overwrite existing file<br> \
FILE_ATTRIBUTE_NORMAL, \
// normal file <br> NULL); & \
nbsp; \
// no template<br> if (hTempFile == \
INVALID_HANDLE_VALUE)<br> {<br> std::cout<<"Error: \
"<<GetLastError()<<std::endl<<"Could not open temp \
File"<<std::endl;<br> \
return;<br> }</p> \
<p> WriteFile(hTempFile,szStartLine,sizeof(szStartLine)-2,&dwByte \
sWritten,NULL);<br> WriteFile(hTempFile,szEventlistTag,sizeof(szEvent \
listTag)-1,&dwBytesWritten,NULL);<br> i=0;<br> ReadFile(hSourceFile, \
buffer, BUFSIZE,&dwBytesRead, NULL);<br> \
do<br> {<br> j=0;<br> & \
nbsp; k=GetCurEvent(buffer+i,lbuffer,&j,&i,&dwBytesRead);<br>&n \
bsp; i+=k; <br> if((i&g \
t;dwBytesRead)||(j==1))<br> {<br> \
<br> k=dwBytesRead-(i-k);<br> SetFilePointer(hSourceFile,-k,NULL,FILE_CURRENT);<br>
break;<br> }<br> &nbs \
p; if(j==-1)<br> { <br> \
break;<br> } <br \
> WriteFile(hTempFile,lbuffer,k,&dwBytesWritten,NULL);  \
> ; <br> <br> }while(i<BUF \
> SIZE);<br> WriteFile(hTempFile,szEventlistEndTag,sizeof(szEventlistEndTag)-1,&dwBytesWritten,NULL);<br>
>
CloseHandle(hTempFile); <br> //Event \
Handle functions here...<br> //<br> <br> \
try{<br> parser_.parse(source);<br> &nbs \
p;dwErrorCount+=parser_.getErrorCount();<br> //std::cout<<"parser_getErrorCount() \
"<<parser_.getErrorCount()<<std::endl;<br> \
if(!(parser_.getErrorCount()))<br> {&nb \
sp; <br> xercesc::DOMDocument* \
xmlDoc = parser_.getDocument() \
;<br> xercesc::DOMElement* elementConfig = \
xmlDoc->getDocumentElement() ;<br> if( NULL == \
elementConfig ){<br> throw( std::runtime_error( \
"empty XML document" ) ) \
;<br> }<br> xercesc::DOMNodeList* \
children = elementConfig->getElementsByTagName \
(tags_.TAG_event.asXMLString());<br> <br> const \
XMLSize_t nodeCount = children->getLength() ;<br> \
<br> for( XMLSize_t ix = 0 \
; ix < nodeCount ; ++ix \
){<br> xercesc::DOMNode* currentNode = \
children->item( ix ) ;<br> if( NULL == \
currentNode ){<br> // null \
node...<br> continue \
;<br> }<br> \
if( xercesc::DOMNode::ELEMENT_NODE != \
currentNode->getNodeType() ){<br> // not \
an element node -> not of interest \
here<br> continue \
;<br> }<br> xercesc::DOMElement* \
currentElement = (xercesc::DOMElement*)( currentNode ) ;<br> \
EventType=handleEvent( currentElement ) \
;<br> <br> switc \
h(EventType)<br> { <br> case \
10:<br> {<br> DOMNodeIterator* \
iterator = outXmlDoc->createNodeIterator(pAddedFiles, DOMNodeFilter::SHOW_TEXT, \
NULL, true);<br> DOMNode* pCurrent = \
NULL;<br> // use the tree walker to \
print out the text nodes. \
<br> for ( pCurrent = \
iterator->nextNode();pCurrent != 0; pCurrent = \
iterator->nextNode())<br> {<br> char \
*strValue = XMLString::transcode( pCurrent->getNodeValue() );<br> \
if(!strcmp(strValue,Path_.c_str( \
)))<br> {<br> &n \
bsp; EventType=0; &nbs \
p; <br>&n \
bsp; }<br>   \
; //XMLString::release(&strValue);<br> &nb \
sp; }<br> if(EventType)<br> {<br>
DOMElement* pPath = \
outXmlDoc->createElement( XercesString("Path") \
);<br> pAddedFiles->appendChild(pPath);<br> DOMText* \
pPathnode=outXmlDoc->createTextNode( XercesString(Path_.c_str()) );<br> \
pPath->appendChild(pPathnode) \
;<br> }<br> iterator->release();</p>
<p> break;<br> }//case \
10;<br> case \
11:<br> {<br> DOMNodeIterator* \
iterator= outXmlDoc->createNodeIterator(pAddedFiles, DOMNodeFilter::SHOW_TEXT, \
NULL, true);<br> DOMNodeIterator* \
uiterator = outXmlDoc->createNodeIterator(pUpdatedFiles, DOMNodeFilter::SHOW_TEXT, \
NULL, true);<br> DOMNode* pCurrent = \
NULL;<br> // use the tree walker to \
print out the text nodes. \
<br> for ( pCurrent = \
iterator->nextNode();pCurrent != 0; pCurrent = \
iterator->nextNode())<br> {<br> char \
*strValue = XMLString::transcode( pCurrent->getNodeValue() );<br> \
if(!strcmp(strValue,Path_.c_str( \
)))<br> {<br> &n \
bsp; EventType=0; &nbs \
p; <br> }< \
br> //XMLString::release(&str \
Value); <br> &nb \
sp; }<br> if(EventType){<br> for \
( pCurrent = uiterator->nextNode();pCurrent != 0; pCurrent = \
uiterator->nextNode())<br> \
{<br> char \
*strValue = XMLString::transcode( pCurrent->getNodeValue() \
);<br> if(!strcmp(strValue,Path_. \
c_str()))<br> {<br> &n \
bsp; EventType=0; &nbs \
p; <br> &n \
bsp;}<br> //XMLString::release(&strValue); <br>
}}<br> & \
nbsp; if(EventType)<br> {<br \
> //XMLString::release(&strValue);<br> DOMElement* \
> pPath = outXmlDoc->createElement( XercesString("Path") \
> );<br> pUpdatedFiles->appendChild(pPath);<br>
>
DOMText* \
pPathnode=outXmlDoc->createTextNode( XercesString(Path_.c_str()) \
);<br> pPath->appendChild(pPat \
hnode);<br> }<br> &nbs \
p; uiterator->release();<br> iterator->release();<br>
break;<br> }// \
case(11)...<br> case(12):<br> &nbs \
p; {<br> DOMElement* \
pPath = outXmlDoc->createElement( XercesString("Path") \
);<br> pDeletedFiles->appendChild(pPath);<br>
DOMText* \
pPathnode=outXmlDoc->createTextNode( XercesString(Path_.c_str()) \
);<br> pPath->appendChild(pPat \
hnode);<br> break;<br> } <br> case \
(20):<br> {<br> DOMNodeIterator* \
iterator = outXmlDoc->createNodeIterator(pAddedDirs, DOMNodeFilter::SHOW_TEXT, \
NULL, true);<br> DOMNode* pCurrent = \
NULL;<br> // use the tree walker to \
print out the text nodes. \
<br> for ( pCurrent = \
iterator->nextNode();pCurrent != 0; pCurrent = \
iterator->nextNode())<br> {<br> char \
*strValue = XMLString::transcode( pCurrent->getNodeValue() );<br> \
if(!strcmp(strValue,Path_.c_str( \
)))<br> {<br> &n \
bsp; EventType=0; &nbs \
p; <br>&n \
bsp; }<br>   \
; //XMLString::release(&strValue);<br> &nb \
sp; }<br> if(EventType)<br> {</p>
<p> DOMElement* pPath = \
outXmlDoc->createElement( XercesString("Path") \
);<br> pAddedDirs->appendChild(pPath);<br> DOMText* \
pPathnode=outXmlDoc->createTextNode( XercesString(Path_.c_str()) );<br> \
pPath->appendChild(pPathnode) \
;<br> }<br> &nbs \
p; iterator->release();<br> break;</p>
<p> }<br> case \
(21):<br> {<br> \
break;<br> }<br> case \
(22):<br> {<br> DOMElement* \
pPath = outXmlDoc->createElement( XercesString("Path") \
);<br> pDeletedDirs->appendChild(pPath);<br>
DOMText* \
pPathnode=outXmlDoc->createTextNode( XercesString(Path_.c_str()) \
);<br> pPath->appendChild(pPathnode) \
;<br> break;<br> }<br> case \
(30):<br> {<br> DOMNodeIterator* \
iterator = outXmlDoc->createNodeIterator(pAddedRegKey, DOMNodeFilter::SHOW_TEXT, \
NULL, true);<br> DOMNode* pCurrent = \
NULL;<br> // use the tree walker to \
print out the text nodes. \
<br> for ( pCurrent = \
iterator->nextNode();pCurrent != 0; pCurrent = \
iterator->nextNode())<br> {<br> char \
*strValue = XMLString::transcode( pCurrent->getNodeValue() );<br> \
if(!strcmp(strValue,Path_.c_str( \
)))<br> {<br> &n \
bsp; EventType=0; &nbs \
p; <br>&n \
bsp; }<br>   \
; //XMLString::release(&strValue);<br> &nb \
sp; }<br> if(EventType)<br> {</p>
<p> DOMElement* pPath = \
outXmlDoc->createElement( XercesString("Path") \
);<br> pAddedRegKey->appendChild(pPath);<br> DOMText* \
pPathnode=outXmlDoc->createTextNode( XercesString(Path_.c_str()) );<br> \
pPath->appendChild(pPathnode) \
;<br> }<br> &nbs \
p; iterator->release();<br> &nb \
sp; break;<br> }<br> }//end \
of switch <br> }//for \
loop..<br> xmlDoc->release();<br> //std::cin>>dwBytesWritten; <br>
}<br> }<br> catch( \
xercesc::XMLException& e ){</p> <p> // believe it or not, \
XMLException is not<br> // a parent class of \
DOMException<br> char* message = \
xercesc::XMLString::transcode( e.getMessage() ) \
;<br> std::ostringstream buf ;<br> buf \
<< "Error parsing file: "<br> << \
message<br> << \
std::flush;<br> xercesc::XMLString::release( &message ) \
;<br> throw( std::runtime_error( buf.str() ) ) \
;<br> }<br> catch( const xercesc::DOMException& \
e ){</p> <p> char* message = xercesc::XMLString::transcode( \
e.getMessage() ) ;<br> std::ostringstream buf \
;<br> buf << "Encountered DOM Exception: \
"<br> << message<< \
std::flush;<br> xercesc::XMLString::release( &message ) \
;<br> throw( std::runtime_error( buf.str() ) ) \
;<br> }<br> if((j==-1))<br> { \
<br> break;<br> }<br> <br> }<br> \
DOMRange* range = outXmlDoc->createRange();<br> \
range->release(); <br> \
parser_.resetDocument();<br> \
<br> }while(dwBytesRead==BUFSIZE);</p> \
<p> //Here should be write file...</p> \
<p> pSerializer->writeNode(pTarget, *outXmlDoc);</p> \
<p> if(dwErrorCount)<br> {<br> std::cout<<"Number \
of errors in file = "<<dwErrorCount<<std::endl<<":-(" \
;<br> }<br> else<br> {<br> std::cout<<"No \
Errors found in file ;-)"<<std::endl;<br> \
std::cout<<"Number of Files Created= \
"<<CreateFileCount<<std::endl;<br> std::cout<<"Number \
of Files Deleted= "<<DeleteFileCount<<std::endl; <br> std::cout<<"Number \
of Folders Created= "<<CreateFolderCount<<std::endl;<br> \
<br> }<br> //std::cin>>dwBytesWritten;<br> <br> }//if \
(outXmlFile)...end<br> <br> delete pTarget;<br> delete \
pSerializer;<br> delete outXmlDoc;<br> delete outXmlDoctype;</p> \
<p> DeleteFile(szTempName);<br> CloseHandle(hSourceFile); <br> return \
;<br> } // load()</p><br clear="all"><br>-- <br>Regards<br>Sree Harsha Vardhana \
S.N<br>"When you want something, all the universe conspires in helping you \
to<br> achieve it."
[prev in list] [next in list] [prev in thread] [next in thread]
Configure |
About |
News |
Add a list |
Sponsored by KoreLogic