int main( int argc, char **argv ){
m_doc = openDocument( argv[1] );
DOMElement *root = m_doc->getDocumentElement();
DOMNodeList *parts = root->getElementsByTagName(XS("part"));
/*
*/
DOMElement *part1 = (DOMElement*)parts->item(0);
DOMElement *part2 = (DOMElement*)parts->item(1);
mergeParts( part1, part2 );
root->removeChild( part2 );
DOMElement *partlist = getSingleElement( root, "part-list" );
partlist->removeChild( partlist->getElementsByTagName(XS("score-part"))->item(1) );
writeFile("merged.xml");
}
int ModelicaXML::serializeEachMoFileInDirectory(char *directoryName)
{
typedef std::string mstring;
mstring filename;
l_list dirList;
getDirectoryStructure(directoryName, dirList);
std::list<char*>::const_iterator it;
for(it=dirList.begin(); it!=dirList.end(); ++it)
{
l_list fileList;
getFileList(*it, fileList, "*.mo");
if (fileList.size()) fileList = sortMoFiles(fileList);
cout << "Found: " << fileList.size() << " *.mo files in directory: " << *it << endl;
if (!fileList.size()) { continue; }
std::list<char*>::const_iterator itFileList;
for(itFileList=fileList.begin(); itFileList!=fileList.end(); ++itFileList)
{
filename = mstring(*itFileList);
cout << " [" << filename << "]" << endl;
DOMElement* pModelicaXML = createModelicaXMLDOMElement(filename.c_str());
// if is not NULL append it to the <modelica></modelica> element
if (pModelicaXML) pRootElementModelica->appendChild(pModelicaXML);
// vomit the current XML Document to file
std::string xmlFile(filename.c_str());
xmlFile += ".xml";
serializeXMLDocumentToFile(xmlFile);
if (pModelicaXML) pRootElementModelica->removeChild(pModelicaXML);
}
if (fileList.size()) cout << endl;
}
return 0;
}
int main()
{
try {
XMLPlatformUtils::Initialize();
}
catch (const XMLException& toCatch) {
char *pMessage = XMLString::transcode(toCatch.getMessage());
fprintf(stderr, "Error during XMLPlatformUtils::Initialize(). \n"
" Message is: %s\n", pMessage);
XMLString::release(&pMessage);
return -1;
}
/*
Range tests include testing of
createRange
setStart, setStartBefore. setStartAfter,
setEnd, setEndBefore. setEndAfter
getStartContainer, getStartOffset
getEndContainer, getEndOffset
getCommonAncestorContainer
selectNode
selectNodeContents
insertNode
deleteContents
collapse
getCollapsed
surroundContents
compareBoundaryPoints
cloneRange
cloneContents
extractContents
toString
detach
removeChild
*/
{
XMLCh tempStr[100];
XMLString::transcode("Range",tempStr,99);
{
DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(tempStr);
DOMDocument* doc = impl->createDocument();
//Creating a root element
DOMElement* root = doc->createElement(xBody);
doc->appendChild(root);
//Creating the siblings of root
DOMElement* E11 = doc->createElement(xH1);
root->appendChild(E11);
DOMElement* E12 = doc->createElement(xP);
root->appendChild(E12);
//Attaching texts to siblings
DOMText* textNode1 = doc->createTextNode(xTitle);
E11->appendChild(textNode1);
DOMText* textNode11 = doc->createTextNode(xAnotherText);
E11->appendChild(textNode11);
DOMText* textNode2 = doc->createTextNode(xBlahxyz);
E12->appendChild(textNode2);
DOMText* E210 = doc->createTextNode(xInsertedText);
doc->release();
}
{
//DOM Tree and some usable node creation
DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(tempStr);
DOMDocument* doc = impl->createDocument();
//Creating a root element
DOMElement* root = doc->createElement(xBody);
doc->appendChild(root);
//Creating the siblings of root
DOMElement* E11 = doc->createElement(xH1);
root->appendChild(E11);
DOMElement* E12 = doc->createElement(xP);
root->appendChild(E12);
//Attaching texts to siblings
DOMText* textNode1 = doc->createTextNode(xTitle);
E11->appendChild(textNode1);
DOMText* textNode11 = doc->createTextNode(xAnotherText);
E11->appendChild(textNode11);
DOMText* textNode2 = doc->createTextNode(xBlahxyz);
E12->appendChild(textNode2);
//experimental nodes
DOMElement* E120 = doc->createElement(xElement1);
DOMElement* E121 = doc->createElement(xElement2);
DOMElement* E122 = doc->createElement(xElement3);
DOMElement* E311 = doc->createElement(xSurroundNode1);
DOMText* E210 = doc->createTextNode(xInsertedText);
DOMNode* rt = doc->getDocumentElement();
DOMRange* range = ((DOMDocumentRange*)doc)->createRange();
//Tests start here
// Initial dom tree looks like :
// <Body><H1>TitleAnother Text</H1><P>Blah xyz</P></Body>
//i.e., Body(rt)
// _____________|________________
// | |
// ___H1(E11)___ P(E12)
// | | |
// "Title" "Another Text" "Blah xyz"
//test for start and end settings of a range
range->setStart(rt->getFirstChild(), 0);
TASSERT(range->getStartContainer() == rt->getFirstChild() );
TASSERT(range->getStartOffset() == 0);
range->setEnd(rt->getFirstChild(), 1);
TASSERT(range->getEndContainer() == rt->getFirstChild() );
TASSERT(range->getEndOffset() == 1);
//DOMNode* node = range->getCommonAncestorContainer();
TASSERT(range->getCommonAncestorContainer() == rt->getFirstChild());
//selection related test
range->selectNode(rt->getLastChild());
TASSERT(range->getStartContainer() == rt);
TASSERT(range->getStartOffset() == 1);
TASSERT(range->getEndContainer() == rt);
TASSERT(range->getEndOffset() == 2);
//insertion related tests
range->insertNode(E120);
//only end offset moves and new node gets into range as being inserted at boundary point
TASSERT(range->getStartContainer() == rt);
TASSERT(range->getStartOffset() == 1);
TASSERT(range->getEndContainer() == rt);
TASSERT(range->getEndOffset() == 3);
range->insertNode(E121);
//only end offset moves and new node gets into range as being inserted at boundary point
TASSERT(range->getStartContainer() == rt);
TASSERT(range->getStartOffset() == 1);
TASSERT(range->getEndContainer() == rt);
TASSERT(range->getEndOffset() == 4);
rt->insertBefore(E122, rt->getFirstChild());
//both offsets move as new node is not part of the range
TASSERT(range->getStartContainer() == rt);
TASSERT(range->getStartOffset() == 2);
TASSERT(range->getEndContainer() == rt);
TASSERT(range->getEndOffset() == 5);
//After above operations, now the tree looks like:
// <Body><Element3/><H1>TitleAnother Text</H1><Element2/><Element1/><P>Blah xyz</P></Body>
//i.e., Body(rt)
// _____________|_______________________________________________________________
// | | | | |
// Element3(E122) ___H1(E11)___ Element2(E121) Element1(E120) P(E12)
// | | |
// "Title" "Another Text" "Blah xyz"
//
// range has rt as start and end container, and 2 as start offset, 5 as end offset
//changing selection
range->selectNode(rt->getLastChild()->getPreviousSibling());
TASSERT(range->getStartContainer() == rt);
TASSERT(range->getStartOffset() == 3);
TASSERT(range->getEndContainer() == rt);
TASSERT(range->getEndOffset() == 4);
//deleting related tests
range->deleteContents();
TASSERT(rt->getLastChild()->getPreviousSibling() == E121);
range->setStart(rt->getFirstChild()->getNextSibling()->getFirstChild(), 2);
TASSERT(range->getStartContainer() == rt->getFirstChild()->getNextSibling()->getFirstChild());
TASSERT(!XMLString::compareString(range->getStartContainer()->getNodeValue(),xTitle));
TASSERT(range->getStartOffset() == 2);
range->setEnd(rt->getFirstChild()->getNextSibling()->getFirstChild(), 4);
TASSERT(range->getEndContainer() == rt->getFirstChild()->getNextSibling()->getFirstChild());
TASSERT(!XMLString::compareString(range->getEndContainer()->getNodeValue(),xTitle));
TASSERT(range->getEndOffset() == 4);
TASSERT(!XMLString::compareString(range->toString(),xtl));
//inserting text between a text node
range->insertNode(E210);
//only end offset moves and new node gets into range as being inserted at boundary point
TASSERT(range->getStartContainer() == rt->getFirstChild()->getNextSibling()->getFirstChild());
TASSERT(range->getStartOffset() == 2);
TASSERT(range->getEndContainer() == rt->getFirstChild()->getNextSibling()->getLastChild()->getPreviousSibling());
TASSERT(range->getEndOffset() == 2);
//inserting element node before the selected text node
range->insertNode(E120);
//only end offset moves and new node gets into range as being inserted at boundary point
TASSERT(range->getStartContainer() == rt->getFirstChild()->getNextSibling()->getFirstChild());
TASSERT(!XMLString::compareString(range->getStartContainer()->getNodeValue(),xTi));
TASSERT(range->getStartOffset() == 2);
TASSERT(range->getEndContainer() == rt->getFirstChild()->getNextSibling()->getLastChild()->getPreviousSibling());
TASSERT(!XMLString::compareString(range->getEndContainer()->getNodeValue(),xtle));
TASSERT(range->getEndOffset() == 2);
TASSERT(E11->getChildNodes()->getLength()==6);
//checking the text replacment
range->getStartContainer()->setNodeValue(xReplacedText);
//only the start offset is impact
TASSERT(range->getStartContainer() == rt->getFirstChild()->getNextSibling()->getFirstChild());
TASSERT(!XMLString::compareString(range->getStartContainer()->getNodeValue(),xReplacedText));
TASSERT(range->getStartOffset() == 0);
TASSERT(range->getEndContainer() == rt->getFirstChild()->getNextSibling()->getLastChild()->getPreviousSibling());
TASSERT(!XMLString::compareString(range->getEndContainer()->getNodeValue(),xtle));
TASSERT(range->getEndOffset() == 2);
//After above operations, now the tree looks like:
// <Body><Element3/><H1>ReplacedText<Element1/>InsertedTexttleAnother Text</H1><Element2/><P>Blah xyz</P></Body>
//i.e., Body(rt)
// _____________|_______________________________________________________________________________________________
// | | | |
// Element3(E122) ___H1(E11)___________________________________________________________ Element2(E121) P(E12)
// | | | | | | |
// "ReplacedText" "" Element1(E120) "InsertedText"(E210) "tle" "Another Text" "Blah xyz"
//
// range has "ReplacedText" as start container and "tle" as end container
// and 0 as start offset, 2 as end offset
//changing the selection. Preparing for 'surround'
range->setStart(range->getStartContainer()->getParentNode(), 2);
range->setEnd(range->getStartContainer(), 5);
TASSERT(!XMLString::compareString(range->getStartContainer()->getNodeName(),xH1));
TASSERT(!XMLString::compareString(range->getEndContainer()->getNodeName(),xH1));
TASSERT(!XMLString::compareString(range->toString(),xInsertedTexttle));
range->surroundContents(E311);
TASSERT(!XMLString::compareString(range->getStartContainer()->getNodeName(),xH1));
TASSERT(range->getStartOffset() == 2);
TASSERT(!XMLString::compareString(range->getEndContainer()->getNodeName(),xH1));
TASSERT(range->getEndOffset() == 3);
TASSERT(E11->getChildNodes()->getLength()==4);
TASSERT(E311->getChildNodes()->getLength()==3);
TASSERT(!XMLString::compareString(range->toString(),xInsertedTexttle));
//After above operations, now the tree looks like:
// <Body><Element3/><H1>ReplacedText<SurroundNode1><Element1/>InsertedTexttle</SurroundNode1>Another Text</H1><Element2/><P>Blah xyz</P></Body>
//i.e., Body(rt)
// _____________|_________________________________________________________________________
// | | | |
// Element3(E122) ___H1(E11)___________________________________ Element2(E121) P(E12)
// | | | | |
// "ReplacedText" "" SurroundNode1(E311) "Another Text" "Blah xyz"
// ____________ |_____________________________
// | | |
// Element1(E120) "InsertedText"(E210) "tle"
//
// range has H1 as start and end container and 2 as start offset, 3 as end offset
//testing cloning
DOMRange* aRange = range->cloneRange();
TASSERT(aRange->getStartContainer() == range->getStartContainer());
TASSERT(aRange->getEndContainer() == range->getEndContainer());
TASSERT(aRange->getStartOffset() == 2);
TASSERT(aRange->getEndOffset() == 3);
//changing the new ranges start
aRange->setStart(aRange->getStartContainer()->getFirstChild(), 1);
//comparing the ranges
short compVal = range->compareBoundaryPoints(DOMRange::END_TO_END, aRange);
TASSERT(compVal == 0);
compVal = range->compareBoundaryPoints(DOMRange::START_TO_START, aRange);
TASSERT(compVal == 1);
compVal = range->compareBoundaryPoints(DOMRange::START_TO_END, aRange);
TASSERT(compVal == 1);
compVal = range->compareBoundaryPoints(DOMRange::END_TO_START, aRange);
TASSERT(compVal == -1);
//testing collapse
//not collapsed
TASSERT(range->getCollapsed() == false);
TASSERT(range->getStartOffset() == 2);
TASSERT(range->getEndOffset() == 3);
//selectNodeContents
range->selectNodeContents(rt->getLastChild()->getFirstChild());
TASSERT(range->getStartContainer() == rt->getLastChild()->getFirstChild());
TASSERT(range->getEndContainer() == rt->getLastChild()->getFirstChild());
TASSERT(range->getStartOffset() == 0);
TASSERT(range->getEndOffset() == 8);
TASSERT(!XMLString::compareString(range->toString(),xBlahxyz));
//testing collapse
range->collapse(true); //collapse to start
TASSERT(range->getCollapsed() == true);
TASSERT(range->getStartOffset() == 0);
TASSERT(range->getEndOffset() == 0);
TASSERT(!XMLString::compareString(range->toString(),XMLUni::fgZeroLenString));
TASSERT(aRange->getEndOffset() == 3); //other range is unaffected
TASSERT(!XMLString::compareString(aRange->toString(),xeplacedTextInsertedTexttle));
//After above operations, now the tree looks like:
// <Body><Element3/><H1>ReplacedText<SurroundNode1><Element1/>InsertedTexttle</SurroundNode1>Another Text</H1><Element2/><P>Blah xyz</P></Body>
//i.e., Body(rt)
// _____________|_________________________________________________________________________
// | | | |
// Element3(E122) ___H1(E11)___________________________________ Element2(E121) P(E12)
// | | | | |
// "ReplacedText" "" SurroundNode1(E311) "Another Text" "Blah xyz"
// ____________ |_____________________________
// | | |
// Element1(E120) "InsertedText"(E210) "tle"
//
// range has "Blah xyz" as start and end container and 0 as start and end offset (collapsed)
// aRange has "ReplacedText" as start container and H1 as end container
// and 1 as start offset and 3 as end offset
DOMDocumentFragment* docFrag = aRange->cloneContents();
TASSERT( docFrag != 0);
range->selectNode(rt->getFirstChild());
TASSERT(range->getStartContainer() == rt);
TASSERT(range->getEndContainer() == rt);
TASSERT(range->getStartOffset() == 0);
TASSERT(range->getEndOffset() == 1);
//Testing toString()
const XMLCh* str = aRange->toString();
TASSERT(!XMLString::compareString(str, xeplacedTextInsertedTexttle));
//start and end before and after tests
range->setStartBefore(rt->getFirstChild());
TASSERT(range->getStartOffset() == 0);
range->setEndBefore(rt->getFirstChild());
TASSERT(range->getEndOffset() == 0);
range->setStartAfter(rt->getLastChild());
TASSERT(range->getStartOffset() == 4);
range->setStartAfter(rt->getFirstChild());
TASSERT(range->getStartOffset() == 1);
range->setEndBefore(rt->getLastChild());
TASSERT(range->getEndOffset() == 3);
range->setEndAfter(rt->getLastChild());
TASSERT(range->getEndOffset() == 4);
//testing extract()
DOMDocumentFragment* frag2 = range->extractContents();
TASSERT( frag2 != 0);
//After above operations, now the tree looks like:
// <Body><Element3/></Body>
//i.e., Body(rt)
// |
// Element3(E122)
//
// aRange has rt as start and end container, and 1 as start and end offset (collapsed)
// range has rt as start and end container, and 1 as start and end offset (collapsed)
//
//and frag2 looks:
// <Body>ReplacedText<SurroundNode1><Element1/>InsertedTexttle</SurroundNode1>Another Text</H1><Element2/><P>Blah xyz</P></Body>
//i.e., Body(rt)
// ______________|________________________________________________________
// | | |
// ___H1(E11)___________________________________ Element2(E121) P(E12)
// | | | | |
//"ReplacedText" "" SurroundNode1(E311) "Another Text" "Blah xyz"
// ____________ |_____________________________
// | | |
// Element1(E120) "InsertedText"(E210) "tle"
//
//the tree do not have those node anymore after extract
//only Element3 left
TASSERT(rt->getChildNodes()->getLength()==1);
//aRange is collapsed
TASSERT(aRange->getCollapsed() == true);
TASSERT(aRange->getStartContainer() == rt);
TASSERT(aRange->getStartOffset() == 1);
TASSERT(aRange->getEndContainer() == rt);
TASSERT(aRange->getEndOffset() == 1);
//range is collapsed as well
TASSERT(range->getCollapsed() == true);
TASSERT(range->getStartContainer() == rt);
TASSERT(range->getStartOffset() == 1);
TASSERT(range->getEndContainer() == rt);
TASSERT(range->getEndOffset() == 1);
//test the document fragment frag2
TASSERT(frag2->getChildNodes()->getLength()==3);
//detaching the other range
aRange->detach();
range->detach();
//***************************************************************
//another set of test
//TEST createRange, setStart and setEnd, insertnode
//***************************************************************
DOMImplementation* impl2 = DOMImplementationRegistry::getDOMImplementation(tempStr);
DOMDocument* doc2 = impl2->createDocument();
DOMElement* root2 = doc2->createElement(xroot2);
doc2->appendChild(root2);
//case 1: simple text node, start==end
// <body>text1</body>
DOMElement* body = doc2->createElement(xBody);
DOMText* text1 = doc2->createTextNode(xtext1);
body->appendChild(text1);
root2->appendChild(body);
//set range
DOMRange* range1 = doc2->createRange();
range1->setStart(text1,1);
range1->setEnd(text1,3);
TASSERT(!XMLString::compareString(range1->toString(),xex));
TASSERT(range1->getStartOffset()==1);
TASSERT(!XMLString::compareString(range1->getStartContainer()->getNodeValue(),xtext1));
TASSERT(range1->getEndOffset()==3);
TASSERT(!XMLString::compareString(range1->getEndContainer()->getNodeValue(),xtext1));
//now insert a text node
//<body>ttext2ext1</body>
DOMText* text2 = doc2->createTextNode(xtext2);
range1->insertNode(text2);
TASSERT(!XMLString::compareString(range1->toString(),xtext2ex));
TASSERT(range1->getStartOffset()==1);
TASSERT(!XMLString::compareString(range1->getStartContainer()->getNodeValue(),xt));
TASSERT(range1->getEndOffset()==2);
TASSERT(!XMLString::compareString(range1->getEndContainer()->getNodeValue(),xext1));
//now insert a non-text node
//<body>t<p1/>text2ext1</body>
DOMElement* p1 = doc2->createElement(xp1);
range1->insertNode(p1);
TASSERT(!XMLString::compareString(range1->toString(),xtext2ex));
TASSERT(range1->getStartOffset()==1);
TASSERT(!XMLString::compareString(range1->getStartContainer()->getNodeValue(),xt));
TASSERT(range1->getEndOffset()==2);
TASSERT(!XMLString::compareString(range1->getEndContainer()->getNodeValue(),xext1));
//case 2: non-text node, start==end
// <head><h1/></head>
DOMElement* head = doc2->createElement(xhead);
DOMElement* h1 = doc2->createElement(xH1);
head->appendChild(h1);
root2->appendChild(head);
//set range
DOMRange* range2 = doc2->createRange();
range2->setStart(head,0);
range2->setEnd(head,1);
TASSERT(!XMLString::compareString(range2->toString(),XMLUni::fgZeroLenString));
TASSERT(range2->getStartOffset()==0);
TASSERT(!XMLString::compareString(range2->getStartContainer()->getNodeName(),xhead));
TASSERT(range2->getEndOffset()==1);
TASSERT(!XMLString::compareString(range2->getEndContainer()->getNodeName(),xhead));
//now insert a non-text node
//<head><h2/><h1/></head>
DOMElement* h2 = doc2->createElement(xh2);
range2->insertNode(h2);
TASSERT(!XMLString::compareString(range2->toString(),XMLUni::fgZeroLenString));
TASSERT(range2->getStartOffset()==0);
TASSERT(!XMLString::compareString(range2->getStartContainer()->getNodeName(),xhead));
TASSERT(range2->getEndOffset()==2);
TASSERT(!XMLString::compareString(range2->getEndContainer()->getNodeName(),xhead));
//now insert a text node
//<head>text5<h2/><h1/></head>
DOMText* text5 = doc2->createTextNode(xtext5);
range2->insertNode(text5);
TASSERT(!XMLString::compareString(range2->toString(),xtext5));
TASSERT(range2->getStartOffset()==0);
TASSERT(!XMLString::compareString(range2->getStartContainer()->getNodeName(),xhead));
TASSERT(range2->getEndOffset()==3);
TASSERT(!XMLString::compareString(range2->getEndContainer()->getNodeName(),xhead));
//case 3: simple text node, start!=end
// <body2>text3</body2>
DOMElement* body2 = doc2->createElement(xbody2);
DOMText* text3 = doc2->createTextNode(xtext3);
body2->appendChild(text3);
root2->appendChild(body2);
//set range
DOMRange* range3 = ((DOMDocumentRange*)doc2)->createRange();
range3->setStart(text3,1);
range3->setEnd(body2,1);
TASSERT(!XMLString::compareString(range3->toString(),xext3));
TASSERT(range3->getStartOffset()==1);
TASSERT(!XMLString::compareString(range3->getStartContainer()->getNodeValue(),xtext3));
TASSERT(range3->getEndOffset()==1);
TASSERT(!XMLString::compareString(range3->getEndContainer()->getNodeName(),xbody2));
//now insert a textnode
//<body2>ttext4ext3</body2>
DOMText* text4 = doc2->createTextNode(xtext4);
range3->insertNode(text4);
TASSERT(!XMLString::compareString(range3->toString(),XMLUni::fgZeroLenString));
TASSERT(range3->getStartOffset()==1);
TASSERT(!XMLString::compareString(range3->getStartContainer()->getNodeValue(),xt));
TASSERT(range3->getEndOffset()==1);
TASSERT(!XMLString::compareString(range3->getEndContainer()->getNodeName(),xbody2));
//now insert a non-text node
//<body2>t<p2/>text4ext3</body2>
DOMElement* p2 = doc2->createElement(xp2);
range3->insertNode(p2);
//extra empty node caused by splitting 't'
TASSERT(!XMLString::compareString(range3->toString(),XMLUni::fgZeroLenString));
TASSERT(range3->getStartOffset()==1);
TASSERT(!XMLString::compareString(range3->getStartContainer()->getNodeValue(),xt));
TASSERT(range3->getEndOffset()==1);
TASSERT(!XMLString::compareString(range3->getEndContainer()->getNodeName(),xbody2));
//test toString a bit
range3->setStart(body2,1);
range3->setEnd(body2,5);
TASSERT(!XMLString::compareString(range3->toString(),xtext4ext3));
range3->setStart(body2,0);
range3->setEnd(body2,5);
TASSERT(!XMLString::compareString(range3->toString(),xttext4ext3));
//case 4: non-text node, start!=end
// <head2><h3/></head2>
DOMElement* head2 = doc2->createElement(xhead2);
DOMElement* h3 = doc2->createElement(xh3);
head2->appendChild(h3);
root2->appendChild(head2);
//set range
DOMRange* range4 = doc2->createRange();
range4->setStart(head2,0);
range4->setEnd(h3,0);
TASSERT(!XMLString::compareString(range4->toString(),XMLUni::fgZeroLenString));
TASSERT(range4->getStartOffset()==0);
TASSERT(!XMLString::compareString(range4->getStartContainer()->getNodeName(),xhead2));
TASSERT(range4->getEndOffset()==0);
TASSERT(!XMLString::compareString(range4->getEndContainer()->getNodeName(),xh3));
//now insert a non-text node
//<head2><h4/><h3/></head2>
DOMElement* h4 = doc2->createElement(xh4);
range4->insertNode(h4);
TASSERT(!XMLString::compareString(range4->toString(),XMLUni::fgZeroLenString));
TASSERT(range4->getStartOffset()==0);
TASSERT(!XMLString::compareString(range4->getStartContainer()->getNodeName(),xhead2));
TASSERT(range4->getEndOffset()==0);
TASSERT(!XMLString::compareString(range4->getEndContainer()->getNodeName(),xh3));
//now insert a text node
//<head2>text6<h4/><h3/></head2>
DOMText* text6 = doc2->createTextNode(xtext6);
range4->insertNode(text6);
TASSERT(!XMLString::compareString(range4->toString(),xtext6));
TASSERT(range4->getStartOffset()==0);
TASSERT(!XMLString::compareString(range4->getStartContainer()->getNodeName(),xhead2));
TASSERT(range4->getEndOffset()==0);
TASSERT(!XMLString::compareString(range4->getEndContainer()->getNodeName(),xh3));
//***************************************************************
// quick test of updating
//***************************************************************
// <upbody>text1</upbody>
DOMElement* upbody = doc2->createElement(xupbody);
DOMText* uptext1 = doc2->createTextNode(xuptext1);
upbody->appendChild(uptext1);
root2->appendChild(upbody);
DOMRange* uprange = ((DOMDocumentRange*)doc2)->createRange();
uprange->setStart(upbody,0);
uprange->setEnd(upbody,1);
TASSERT(!XMLString::compareString(uprange->toString(),xuptext1));
TASSERT(uprange->getStartOffset()==0);
TASSERT(!XMLString::compareString(uprange->getStartContainer()->getNodeName(),xupbody));
TASSERT(uprange->getEndOffset()==1);
TASSERT(!XMLString::compareString(uprange->getEndContainer()->getNodeName(),xupbody));
// split text
uptext1->splitText(1);
TASSERT(!XMLString::compareString(uprange->toString(),xu));
TASSERT(uprange->getStartOffset()==0);
TASSERT(!XMLString::compareString(uprange->getStartContainer()->getNodeName(),xupbody));
TASSERT(uprange->getEndOffset()==1);
TASSERT(!XMLString::compareString(uprange->getEndContainer()->getNodeName(),xupbody));
//insert node
DOMElement* upbody2 = doc2->createElement(xupbody2);
DOMText* uptext2 = doc2->createTextNode(xuptext2);
upbody2->appendChild(uptext2);
root2->appendChild(upbody2);
DOMRange* uprange2 = ((DOMDocumentRange*)doc2)->createRange();
uprange2->setStart(uptext2,1);
uprange2->setEnd(upbody2,1);
DOMRange* uprange3 = doc2->createRange();
uprange3->setStart(uptext2,1);
uprange3->setEnd(upbody2,1);
TASSERT(!XMLString::compareString(uprange2->toString(),xptext2));
TASSERT(uprange2->getStartOffset()==1);
TASSERT(!XMLString::compareString(uprange2->getStartContainer()->getNodeValue(),xuptext2));
TASSERT(uprange2->getEndOffset()==1);
TASSERT(!XMLString::compareString(uprange2->getEndContainer()->getNodeName(),xupbody2));
TASSERT(!XMLString::compareString(uprange3->toString(),xptext2));
TASSERT(uprange3->getStartOffset()==1);
TASSERT(!XMLString::compareString(uprange3->getStartContainer()->getNodeValue(),xuptext2));
TASSERT(uprange3->getEndOffset()==1);
TASSERT(!XMLString::compareString(uprange3->getEndContainer()->getNodeName(),xupbody2));
DOMElement* upp1 = doc2->createElement(xupp1);
uprange2->insertNode(upp1);
TASSERT(!XMLString::compareString(uprange2->toString(),XMLUni::fgZeroLenString));
TASSERT(uprange2->getStartOffset()==1);
TASSERT(!XMLString::compareString(uprange2->getStartContainer()->getNodeValue(),xu));
TASSERT(uprange2->getEndOffset()==1);
TASSERT(!XMLString::compareString(uprange2->getEndContainer()->getNodeName(),xupbody2));
TASSERT(!XMLString::compareString(uprange3->toString(),XMLUni::fgZeroLenString));
TASSERT(uprange3->getStartOffset()==1);
TASSERT(!XMLString::compareString(uprange3->getStartContainer()->getNodeValue(),xu));
TASSERT(uprange3->getEndOffset()==1);
TASSERT(!XMLString::compareString(uprange3->getEndContainer()->getNodeName(),xupbody2));
//***************************************************************
//another set of test
//<foo><c/><moo><b/></moo>ab<a>Hello cd</a><cool>ef</cool></foo>
//
// ______________________foo_____________________
// | | | | |
// c moo "ab" a cool
// | | |
// b "Hello cd" "ef"
//
DOMImplementation* impl3 = DOMImplementationRegistry::getDOMImplementation(tempStr);
DOMDocument* doc3 = impl3->createDocument();
DOMElement* root3 = doc3->createElement(xroot);
doc3->appendChild(root3);
DOMElement* foo = doc3->createElement(xfoo);
DOMElement* moo = doc3->createElement(xmoo);
DOMElement* cool = doc3->createElement(xcool);
DOMText* ab = doc3->createTextNode(xab);
DOMText* cd = doc3->createTextNode(xHellocd);
DOMText* ef = doc3->createTextNode(xef);
DOMElement* a = doc3->createElement(xa);
DOMElement* b = doc3->createElement(xb);
DOMElement* c = doc3->createElement(xc);
root3->appendChild(foo);
foo->appendChild(c);
foo->appendChild(moo);
foo->appendChild(ab);
foo->appendChild(a);
foo->appendChild(cool);
moo->appendChild(b);
a->appendChild(cd);
cool->appendChild(ef);
//***************************************************************
//TEST toString
//***************************************************************
DOMRange* newtestrange = ((DOMDocumentRange*)doc3)->createRange();
//case 1:
//start container is text node
// i) end container is also text node
// a) start==end
// b) start!=end
// ii) end container is not text node
// a) start==end => impossible
// b) start!=end
//
//case 2:
//start container is not text node
// i) end container is text node
// a) start==end => impossible
// b) start!=end
// ii) end container is not text node
// a) start==end
// b) start!=end
//case 1, i, a
newtestrange->setStart( cd, 1 );
newtestrange->setEnd( cd, 4 );
TASSERT(!XMLString::compareString(newtestrange->toString(),xell));
//case 1, i, b
newtestrange->setStart( cd, 1 );
newtestrange->setEnd( ef, 2 );
TASSERT(!XMLString::compareString(newtestrange->toString(),xellocdef));
//case 1, ii, b
newtestrange->setStart( cd, 1 );
newtestrange->setEnd( foo, 4 );
TASSERT(!XMLString::compareString(newtestrange->toString(),xellocd));
//case 2, i, b
newtestrange->setStart( foo, 1 );
newtestrange->setEnd( cd, 5 );
TASSERT(!XMLString::compareString(newtestrange->toString(),xabHello));
//case 2, ii, a
newtestrange->setStart( foo, 1 );
newtestrange->setEnd( foo, 4 );
TASSERT(!XMLString::compareString(newtestrange->toString(),xabHellocd));
//case 2, ii, b
newtestrange->setStart( moo, 1 );
newtestrange->setEnd( foo, 4 );
TASSERT(!XMLString::compareString(newtestrange->toString(),xabHellocd));
//***************************************************************
//test removeChild
//***************************************************************
DOMRange* newrange = doc3->createRange();
newrange->setStart( moo, 0 );
newrange->setEnd( foo, 4 );
TASSERT(newrange->getStartOffset()==0);
TASSERT(!XMLString::compareString(newrange->getStartContainer()->getNodeName(),xmoo));
TASSERT(newrange->getEndOffset()==4);
TASSERT(!XMLString::compareString(newrange->getEndContainer()->getNodeName(),xfoo));
TASSERT(!XMLString::compareString(newrange->toString(),xabHellocd));
DOMNode* n = newrange->cloneContents();
DOMNodeList* nol = foo->getChildNodes();
//removing moo
DOMNode* rem = foo->removeChild(nol->item(1));
rem->release();
TASSERT(newrange->getStartOffset()==1);
TASSERT(!XMLString::compareString(newrange->getStartContainer()->getNodeName(),xfoo));
TASSERT(newrange->getEndOffset()==3);
TASSERT(!XMLString::compareString(newrange->getEndContainer()->getNodeName(),xfoo));
TASSERT(!XMLString::compareString(newrange->toString(),xabHellocd));
TASSERT(newtestrange->getStartOffset()==1);
TASSERT(!XMLString::compareString(newtestrange->getStartContainer()->getNodeName(),xfoo));
TASSERT(newtestrange->getEndOffset()==3);
TASSERT(!XMLString::compareString(newtestrange->getEndContainer()->getNodeName(),xfoo));
TASSERT(!XMLString::compareString(newtestrange->toString(),xabHellocd));
// Now do some exception test
newrange->detach();
EXCEPTION_TEST(newrange->setStart( moo, 0 ), DOMException::INVALID_STATE_ERR);
EXCEPTION_TEST(newtestrange->setStartBefore(moo), DOMRangeException::INVALID_NODE_TYPE_ERR);
doc->release();
doc2->release();
doc3->release();
}
} //creating the dom tree and tests
// And call the termination method
XMLPlatformUtils::Terminate();
if (errorOccurred) {
printf("Test Failed\n");
return 4;
}
printf("Test Run Successfully\n");
return 0;
};
int main( )
{
try {
// Initialize Xerces and retrieve a DOMImplementation.
XercesInitializer init;
DOMImplementation* impl =
DOMImplementationRegistry::getDOMImplementation(
fromNative("LS").c_str( )
);
if (impl == 0) {
cout << "couldn't create DOM implementation\n";
return EXIT_FAILURE;
}
// Construct a DOMBuilder to parse animals.xml.
DOMPtr<DOMBuilder> parser =
static_cast<DOMImplementationLS*>(impl)->
createDOMBuilder(
DOMImplementationLS::MODE_SYNCHRONOUS, 0
);
CircusErrorHandler err;
parser->setErrorHandler(&err);
// Parse animals.xml.
DOMDocument* doc =
parser->parseURI("animals.xml");
DOMElement* animalList = doc->getDocumentElement( );
// Create XPath expression.
auto_ptr<XPathEvaluator>
evaluator(XPathEvaluator::createEvaluator( ));
auto_ptr<XPathNSResolver>
resolver(evaluator->createNSResolver(animalList));
auto_ptr<XPathExpression>
xpath(
evaluator->createExpression(
fromNative(
"animalList/animal[child::name='Herby']"
).c_str( ),
resolver.get( )
)
);
auto_ptr<XPathEvaluator> evaluator(XPathEvaluator::createEvaluator( ));
auto_ptr<XPathNSResolver> resolver(evaluator->createNSResolver(animalList));
auto_ptr<XPathExpression> xpath(
evaluator->createExpression(
fromNative("animalList/animal[child::name='Herby']").c_str( ),
resolver.get( )
));
// Evaluate the expression.
XPathResult* result =
xpath->evaluate(
doc,
XPathResult::ORDERED_NODE_ITERATOR_TYPE,
0
);
DOMNode* herby;
if (herby = result->iterateNext( )) {
animalList->removeChild(herby);
herby->release( ); // optional.
}
// Construct a DOMWriter to save animals.xml.
DOMPtr<DOMWriter> writer =
static_cast<DOMImplementationLS*>(impl)->createDOMWriter( );
writer->setErrorHandler(&err);
// Save animals.xml.
LocalFileFormatTarget file("circus.xml");
writer->writeNode(&file, *animalList);
} catch (const DOMException& e) {
cout << toNative(e.getMessage( )) << "\n";
return EXIT_FAILURE;
} catch (const XPathException &e) {
cout << e.getString( ) << "\n";
return EXIT_FAILURE;
} catch (const exception& e) {
cout << e.what( ) << "\n";
return EXIT_FAILURE;
}
}
int main(int /*argc*/, char ** /*argv*/) {
Normalizer *normalizer = new Normalizer();
DOMDocument *doc = normalizer->createDocument();
bool *tmpTrue = new bool(true);
bool *tmpFalse = new bool(false);
DOMElement* docFirstElement = doc->createElementNS(X("http://www.test.com"),X("docEle"));
doc->appendChild(docFirstElement);
DOMElement* docFirstElementChild = doc->createElementNS(X("http://www.test2.com"),X("docEleChild"));
docFirstElement->appendChild(docFirstElementChild);
//create default ns
doc->normalizeDocument();
normalizer->serializeNode(doc);
XERCES_STD_QUALIFIER cout << "\n\n";
//add in binding
docFirstElement->setPrefix(X("po"));
doc->normalizeDocument();
normalizer->serializeNode(doc);
XERCES_STD_QUALIFIER cout << "\n\n";
//use default
DOMElement* docFirstElementChildChild = doc->createElementNS(X("http://www.test2.com"),X("docEleChildChild"));
docFirstElementChild->appendChild(docFirstElementChildChild);
doc->normalizeDocument();
normalizer->serializeNode(doc);
XERCES_STD_QUALIFIER cout << "\n\n";
// this block is needed to destroy the XMLBuffer
{
//use a binding
XMLBuffer buf;
buf.set(XMLUni::fgXMLNSString);
buf.append(chColon);
buf.append(X("po2"));
docFirstElementChild->removeAttributeNS(XMLUni::fgXMLNSURIName, XMLUni::fgXMLNSString);
docFirstElement->removeAttributeNS(XMLUni::fgXMLNSURIName, XMLUni::fgXMLNSString);
docFirstElement->setAttributeNS(XMLUni::fgXMLNSURIName, buf.getRawBuffer(), X("http://www.test2.com"));
docFirstElementChild->setPrefix(X("po2"));
doc->normalizeDocument();
normalizer->serializeNode(doc);
XERCES_STD_QUALIFIER cout << "\n\n";
}
//some siblngs to ensure the scope stacks are working
docFirstElementChildChild = doc->createElementNS(X("http://www.test3.com"),X("docEleChildChild2"));
docFirstElementChild->appendChild(docFirstElementChildChild);
docFirstElementChildChild = doc->createElementNS(X("http://www.test4.com"),X("po4:docEleChildChild3"));
docFirstElementChild->appendChild(docFirstElementChildChild);
docFirstElementChildChild = doc->createElementNS(X("http://www.test4.com"),X("po4:docEleChildChild4"));
docFirstElementChild->appendChild(docFirstElementChildChild);
doc->normalizeDocument();
normalizer->serializeNode(doc);
XERCES_STD_QUALIFIER cout << "\n\n";
//conflicting prefix
docFirstElementChildChild->setAttributeNS(XMLUni::fgXMLNSURIName, X("po4"), X("conflict"));
doc->normalizeDocument();
normalizer->serializeNode(doc);
XERCES_STD_QUALIFIER cout << "\n\n";
//conflicting default
docFirstElementChildChild = doc->createElementNS(X("http://www.test4.com"),X("docEleChildChild5"));
docFirstElementChild->appendChild(docFirstElementChildChild);
docFirstElementChildChild->setAttributeNS(XMLUni::fgXMLNSURIName, XMLUni::fgXMLNSString, X("conflict"));
doc->normalizeDocument();
normalizer->serializeNode(doc);
XERCES_STD_QUALIFIER cout << "\n\n";
//set the xmlns to ""
DOMElement *noNamespaceEle = doc->createElementNS(X(""),X("noNamespace"));
docFirstElementChildChild->appendChild(noNamespaceEle);
doc->normalizeDocument();
normalizer->serializeNode(doc);
XERCES_STD_QUALIFIER cout << "\n\n";
//now lets do a bit off attribute testing on the doc ele
docFirstElement->setAttributeNS(X("http://testattr.com"), X("attr1"), X("value"));
docFirstElement->setAttributeNS(X("http://testattr.com"), X("attr2"), X("value"));
docFirstElement->setAttributeNS(X("http://testattr2.com"), X("attr3"), X("value"));
docFirstElement->setAttributeNS(X("http://www.test.com"), X("attr4"), X("value"));
docFirstElement->setAttributeNS(X("http://testattr2.com"), X("po:attr5"), X("value"));
docFirstElement->setAttributeNS(X("http://testattr2.com"), X("poFake:attr6"), X("value"));
docFirstElement->setAttributeNS(X("http://testattr3.com"), X("po3:attr7"), X("value"));
doc->normalizeDocument();
normalizer->serializeNode(doc);
XERCES_STD_QUALIFIER cout << "\n\n";
//and now on one of its children
docFirstElementChildChild->setAttributeNS(X("http://testattr.com"), X("attr1"), X("value"));
docFirstElementChildChild->setAttributeNS(X("http://testattr.com"), X("attr2"), X("value"));
docFirstElementChildChild->setAttributeNS(X("http://testattr2.com"), X("attr3"), X("value"));
docFirstElementChildChild->setAttributeNS(X("http://www.test.com"), X("attr4"), X("value"));
docFirstElementChildChild->setAttributeNS(X("http://testattr2.com"), X("po:attr5"), X("value"));
docFirstElementChildChild->setAttributeNS(X("http://testattr2.com"), X("poFake:attr6"), X("value"));
docFirstElementChildChild->setAttributeNS(X("http://testattr3.com"), X("po3:attr7"), X("value"));
docFirstElementChildChild->setAttributeNS(X("http://testattr4.com"), X("po4:attr8"), X("value"));
//test for a clash with our NSx attrs
docFirstElementChildChild->setAttributeNS(X("http://testclash.com"), X("NS1:attr9"), X("value"));
docFirstElementChildChild->setAttributeNS(XMLUni::fgXMLNSURIName, X("xmlns:NS1"), X("http://testclash.com"));
//clash with standard prefix
docFirstElementChildChild->setAttributeNS(X("http://testattr5.com"), X("po:attr10"), X("value"));
doc->normalizeDocument();
normalizer->serializeNode(doc);
XERCES_STD_QUALIFIER cout << "\n\n";
//2 prefix with the same uri
docFirstElementChildChild = doc->createElementNS(X("http://www.uri1.com"),X("docEleChildChild6"));
docFirstElementChild->appendChild(docFirstElementChildChild);
docFirstElementChildChild->setAttributeNS(XMLUni::fgXMLNSURIName, X("xmlns:uri1"), X("http://www.uri1.com"));
docFirstElementChildChild->setAttributeNS(XMLUni::fgXMLNSURIName, X("xmlns:uri1b"), X("http://www.uri1.com"));
docFirstElementChildChild->setAttributeNS(X("http://www.uri1.com"), X("uri1:attr1"), X("value"));
docFirstElementChildChild->setAttributeNS(X("http://www.uri1.com"), X("uri1b:attr2"), X("value"));
doc->normalizeDocument();
normalizer->serializeNode(doc);
XERCES_STD_QUALIFIER cout << "\n\n";
//check to see we use the nearest binding and for more inheritence
DOMElement *docFirstElementChildChildChild = doc->createElementNS(X("http://www.uri1.com"),X("docEleChildChildChild"));
docFirstElementChildChild->appendChild(docFirstElementChildChildChild);
docFirstElementChildChild->setAttributeNS(XMLUni::fgXMLNSURIName, X("xmlns:nearerThanPo"), X("http://www.test.com"));
docFirstElementChildChildChild->setAttributeNS(X("http://testattr.com"), X("attr2"), X("value"));
docFirstElementChildChildChild->setAttributeNS(X("http://www.test.com"), X("attr1"), X("value"));
doc->normalizeDocument();
normalizer->serializeNode(doc);
XERCES_STD_QUALIFIER cout << "\n\n";
//NS1.1 stuff
//test creating default prefix when NS1 has been set to ""
noNamespaceEle->setAttributeNS(XMLUni::fgXMLNSURIName, X("xmlns:NS1"), X(""));
DOMElement *noNamespaceChild = doc->createElementNS(X("http://testclash.com"),X("testing1.1Stuff"));
noNamespaceEle->appendChild(noNamespaceChild);
doc->normalizeDocument();
normalizer->serializeNode(doc);
noNamespaceChild = doc->createElementNS(X("http://testclash.com"),X("NS1:testing1.1Stuff"));
noNamespaceEle->appendChild(noNamespaceChild);
noNamespaceChild->setAttributeNS(X("http://www.someRandomUri.com"), X("attr"), X("value"));
doc->normalizeDocument();
normalizer->serializeNode(doc);
//check error conditions
XERCES_STD_QUALIFIER cout << "error conditions" << XERCES_STD_QUALIFIER endl;
DOMConfiguration *conf = doc->getDOMConfig();
conf->setParameter(XMLUni::fgDOMErrorHandler, normalizer);
conf->setParameter(XMLUni::fgDOMNamespaces, true);
DOMElement *level1Node = doc->createElement(X("level1Node"));
docFirstElement->appendChild(level1Node);
doc->normalizeDocument();
docFirstElement->removeChild(level1Node);
docFirstElement->setAttribute(X("level1Attr"), X("level1"));
doc->normalizeDocument();
docFirstElement->removeAttribute(X("level1Attr"));
//cant check this as Xerces does not let us do it
// noNamespaceChild->setAttributeNS(X("http://www.someRandomUri.com"), X("xmlns"), X("value"));
// doc->normalizeDocument();
//lets do a sanity test on a comment
DOMComment *comment = doc->createComment(X("some comment"));
docFirstElement->appendChild(comment);
doc->normalizeDocument();
normalizer->serializeNode(doc);
conf->setParameter(XMLUni::fgDOMComments, false);
docFirstElement->appendChild(comment);
doc->normalizeDocument();
normalizer->serializeNode(doc);
//and on a CDATA
DOMCDATASection *cData = doc->createCDATASection(X("some cdata"));
docFirstElement->appendChild(cData);
doc->normalizeDocument();
normalizer->serializeNode(doc);
conf->setParameter(XMLUni::fgDOMCDATASections, false);
docFirstElement->appendChild(cData);
doc->normalizeDocument();
normalizer->serializeNode(doc);
delete normalizer;
delete tmpTrue;
delete tmpFalse;
return 0;
}
int main( )
{
try {
// Initialize Xerces and retrieve a DOMImplementation;
// specify that you want to use the Load and Save (LS)
// feature
XercesInitializer init;
DOMImplementation* impl =
DOMImplementationRegistry::getDOMImplementation(
fromNative("LS").c_str( )
);
if (impl == 0) {
cout << "couldn't create DOM implementation\n";
return EXIT_FAILURE;
}
// Construct a DOMBuilder to parse animals.xml.
DOMPtr<DOMBuilder> parser =
static_cast<DOMImplementationLS*>(impl)->
createDOMBuilder(DOMImplementationLS::MODE_SYNCHRONOUS, 0);
// Enable namespaces (not needed in this example)
parser->setFeature(XMLUni::fgDOMNamespaces, true);
// Register an error handler
CircusErrorHandler err;
parser->setErrorHandler(&err);
// Parse animals.xml; you can use a URL here
// instead of a file name
DOMDocument* doc =
parser->parseURI("animals.xml");
// Search for Herby the elephant: first, obtain a pointer
// to the "animalList" element.
DOMElement* animalList = doc->getDocumentElement( );
if (animalList->getTagName( ) != fromNative("animalList")) {
cout << "bad document root: "
<< toNative(animalList->getTagName( ))
<< "\n";
return EXIT_FAILURE;
}
// Next, iterate through the "animal" elements, searching
// for Herby the elephant.
DOMNodeList* animals =
animalList->getElementsByTagName(fromNative("animal").c_str( ));
for ( size_t i = 0,
len = animals->getLength( );
i < len;
++i )
{
DOMElement* animal =
static_cast<DOMElement*>(animals->item(i));
const XMLCh* name = getAnimalName(animal);
if (name != 0 && name == fromNative("Herby")) {
// Found Herby -- remove him from document.
animalList->removeChild(animal);
animal->release( ); // optional.
break;
}
}
// Construct a DOMWriter to save animals.xml.
DOMPtr<DOMWriter> writer =
static_cast<DOMImplementationLS*>(impl)->createDOMWriter( );
writer->setErrorHandler(&err);
// Save animals.xml.
LocalFileFormatTarget file("animals.xml");
writer->writeNode(&file, *animalList);
} catch (const SAXException& e) {
cout << "xml error: " << toNative(e.getMessage( )) << "\n";
return EXIT_FAILURE;
} catch (const DOMException& e) {
cout << "xml error: " << toNative(e.getMessage( )) << "\n";
return EXIT_FAILURE;
} catch (const exception& e) {
cout << e.what( ) << "\n";
return EXIT_FAILURE;
}
}
// 2006/11/07
void handleDocument(DOMDocument* document, char* outputfile)
{
if (document == NULL) {
cerr << _PREFIX_ << "WARNING null XML Document\n";
return;
}
DOMElement* docElement = NULL;
docElement = document->getDocumentElement();
if (docElement == NULL) {
cerr << _PREFIX_ << "WARNING null XML Document Element\n";
return;
}
DOMNodeList* sections = docElement->getElementsByTagName(XMLString::transcode("section"));
int sCount = 0;
int paragraphID = 1;
for (unsigned int i = 0; i < sections->getLength(); i++) {
int sectID = i+1;
if (verbose) cerr << _PREFIX_ << "Section " << i;
DOMElement* aSect = NULL;
aSect = (DOMElement*)sections->item(i);
string sectName = XMLString::transcode(((DOMElement*)aSect)->getAttribute(XMLString::transcode("name")));
string analyze =
XMLString::transcode(((DOMElement*)aSect)->getAttribute(XMLString::transcode("analyze")));
if (verbose) cerr << " ['" << sectName << "'";
// Ignore non affected sections
if ( ( analyze == "yes" ) ||
( sectName.length() == 0 ) ||
( affectedSections.find(sectName + "|") != string::npos )) {
if (verbose) cerr << " analyze=yes ";
// Deal with unnamed and affected sections
// create a stream
aSect->normalize();
stringstream text(XMLString::transcode(aSect->getTextContent()));
if (verbose) {
string temp(XMLString::transcode(aSect->getTextContent()));
cerr << temp.length() << " charcters]\n" << _PREFIX_ << " ";
}
aSect->removeChild(aSect->getFirstChild());
vector<vector<string> > result;
result = seg->segmentInVectors(text);
for(vector<vector<string> >::iterator itp = result.begin();
itp != result.end();
itp++) {
stringstream parID;
parID << _ID_PREFIX_SECTION << sectID << _ID_PREFIX_PARAGRAPH << paragraphID++;
sCount += addSegmentedParagraphToSection(*itp,aSect,parID.str().c_str());
}
if (verbose) cerr << endl;
} else {
if (verbose) cerr << " analyze=no]" << endl;
}
}
if (stamp) stampDocument(docElement);
/* SERIALIZE XML DOCUMENT */
if (outputfile == NULL) xmlInterface->serializeTo(document);
else xmlInterface->serializeTo(document,outputfile);
if (verbose) cerr << _PREFIX_ << "Segmented in " << sCount << " sentences." << endl;
}
