const XMLCh* DOMTextImpl::getWholeText() const
{
DOMDocument *doc = getOwnerDocument();
if (!doc) {
throw DOMException(DOMException::NOT_SUPPORTED_ERR, 0, GetDOMNodeMemoryManager);
return 0;
}
DOMNode* root=doc->getDocumentElement();
DOMTreeWalker* pWalker=doc->createTreeWalker(root!=NULL?root:(DOMNode*)this, DOMNodeFilter::SHOW_ALL, NULL, true);
pWalker->setCurrentNode((DOMNode*)this);
// Logically-adjacent text nodes are Text or CDATASection nodes that can be visited sequentially in document order or in
// reversed document order without entering, exiting, or passing over Element, Comment, or ProcessingInstruction nodes.
DOMNode* prevNode;
while((prevNode=pWalker->previousNode())!=NULL)
{
if(prevNode->getNodeType()==ELEMENT_NODE || prevNode->getNodeType()==COMMENT_NODE || prevNode->getNodeType()==PROCESSING_INSTRUCTION_NODE)
break;
}
XMLBuffer buff(1023, GetDOMNodeMemoryManager);
DOMNode* nextNode;
while((nextNode=pWalker->nextNode())!=NULL)
{
if(nextNode->getNodeType()==ELEMENT_NODE || nextNode->getNodeType()==COMMENT_NODE || nextNode->getNodeType()==PROCESSING_INSTRUCTION_NODE)
break;
if(nextNode->getNodeType()==TEXT_NODE || nextNode->getNodeType()==CDATA_SECTION_NODE)
buff.append(nextNode->getNodeValue());
}
pWalker->release();
XMLCh* wholeString = (XMLCh*)((DOMDocumentImpl*)doc)->allocate((buff.getLen()+1) * sizeof(XMLCh));
XMLString::copyString(wholeString, buff.getRawBuffer());
return wholeString;
}
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;
}
// Create a XMLCh buffer for string manipulation
XMLCh tempStr[4000];
XMLCh featureStr[100];
XMLString::transcode("Traversal",featureStr,99);
//
// Doc - Create a small document tree
//
{
//creating a DOM Tree
/* Tests are based on the tree structure below
doc - root - E11 (attr01) - textNode1
- E111
- E112
- cdataSec
- E12 (attr02) - textNode2
- E121
- E122
- E13 - E131
- docPI
- comment
*/
DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(featureStr);
DOMDocument* doc = impl->createDocument();
//Creating a root element
XMLString::transcode("RootElement", tempStr, 3999);
DOMElement* root = doc->createElement(tempStr);
doc->appendChild(root);
//Creating the siblings of root
XMLString::transcode("FirstSibling", tempStr, 3999);
DOMElement* E11 = doc->createElement(tempStr);
root->appendChild(E11);
XMLString::transcode("SecondSibling", tempStr, 3999);
DOMElement* E12 = doc->createElement(tempStr);
root->appendChild(E12);
XMLString::transcode("ThirdSibling", tempStr, 3999);
DOMElement* E13 = doc->createElement(tempStr);
root->appendChild(E13);
//Attaching texts to few siblings
XMLString::transcode("Text1", tempStr, 3999);
DOMText* textNode1 = doc->createTextNode(tempStr);
E11->appendChild(textNode1);
XMLString::transcode("Text2", tempStr, 3999);
DOMText* textNode2 = doc->createTextNode(tempStr);
E12->appendChild(textNode2);
//creating child of siblings
XMLString::transcode("FirstSiblingChild1", tempStr, 3999);
DOMElement* E111 = doc->createElement(tempStr);
E11->appendChild(E111);
XMLString::transcode("Attr01", tempStr, 3999);
DOMAttr* attr01 = doc->createAttribute(tempStr);
DOMNode* rem = E11->setAttributeNode(attr01);
if (rem)
rem->release();
XMLString::transcode("FirstSiblingChild2", tempStr, 3999);
DOMElement* E112 = doc->createElement(tempStr);
E11->appendChild(E112);
XMLString::transcode("SecondSiblingChild1", tempStr, 3999);
DOMElement* E121 = doc->createElement(tempStr);
E12->appendChild(E121);
XMLString::transcode("Attr01", tempStr, 3999);
DOMAttr* attr02 = doc->createAttribute(tempStr);
rem = E12->setAttributeNode(attr02);
if (rem)
rem->release();
XMLString::transcode("SecondSiblingChild2", tempStr, 3999);
DOMElement* E122 = doc->createElement(tempStr);
E12->appendChild(E122);
XMLString::transcode("ThirdSiblingChild1", tempStr, 3999);
DOMElement* E131 = doc->createElement(tempStr);
E13->appendChild(E131);
XMLString::transcode("DocComment", tempStr, 3999);
DOMComment* comment = doc->createComment(tempStr);
root->appendChild(comment);
XMLString::transcode("DocCDataSection", tempStr, 3999);
DOMCDATASection* cdataSec = doc->createCDATASection(tempStr);
E11->appendChild(cdataSec);
XMLString::transcode("DocPI", tempStr, 3999);
XMLCh piStr[] = {chLatin_D, chLatin_o, chLatin_c, chLatin_P, chLatin_I, chNull};
DOMProcessingInstruction* docPI = doc->createProcessingInstruction(piStr, tempStr);
E13->appendChild(docPI);
/*
following are whatToShow types:
SHOW_ALL = 0x0000FFFF,
SHOW_ELEMENT = 0x00000001,
SHOW_ATTRIBUTE = 0x00000002,
SHOW_TEXT = 0x00000004,
SHOW_CDATA_SECTION = 0x00000008,
SHOW_ENTITY_REFERENCE = 0x00000010,
SHOW_ENTITY = 0x00000020,
SHOW_PROCESSING_INSTRUCTION = 0x00000040,
SHOW_COMMENT = 0x00000080,
SHOW_DOCUMENT = 0x00000100,
SHOW_DOCUMENT_TYPE = 0x00000200,
SHOW_DOCUMENT_FRAGMENT = 0x00000400,
SHOW_NOTATION = 0x00000800
*/
////////// NodeIterator Test Cases ////////////////
{
// all node iterating test
DOMNode* node = doc->getFirstChild();
UNUSED(node); // silence warning
unsigned long whatToShow = DOMNodeFilter::SHOW_ALL;
MyFilter* filter = new MyFilter(0);
DOMNodeIterator* iter = ((DOMDocumentTraversal*)doc)->createNodeIterator(root, whatToShow, filter, true);
TASSERT(iter->getWhatToShow() == 65535);
TASSERT(iter->getExpandEntityReferences() == 1);
DOMNode* nd;
nd = iter->nextNode();
TASSERT (nd ==root);
nd = iter->nextNode();
TASSERT (nd ==E11);
nd = iter->nextNode();
TASSERT(nd == textNode1);
nd = iter->nextNode();
TASSERT(nd == E111);
nd = iter->nextNode();
TASSERT(nd == E112);
nd = iter->nextNode();
TASSERT(nd == cdataSec);
nd = iter->nextNode();
TASSERT(nd == E12);
nd = iter->nextNode();
TASSERT(nd == textNode2);
nd = iter->nextNode();
TASSERT(nd == E121);
nd = iter->nextNode();
TASSERT(nd == E122);
nd = iter->nextNode();
TASSERT(nd == E13);
nd = iter->nextNode();
TASSERT(nd == E131);
nd = iter->nextNode();
TASSERT(nd == docPI);
nd = iter->nextNode();
TASSERT(nd == comment);
nd = iter->previousNode();
TASSERT(nd == comment);
nd = iter->previousNode();
TASSERT(nd == docPI);
nd = iter->previousNode();
TASSERT(nd == E131);
//test getRoot
TASSERT(iter->getRoot() == root);
TASSERT(iter->getRoot() != doc);
delete filter;
}
{
//element node iterating test
DOMNode* node = doc->getFirstChild();
UNUSED(node); // silence warning
unsigned long whatToShow = DOMNodeFilter::SHOW_ELEMENT;
MyFilter* filter = new MyFilter(DOMNode::ELEMENT_NODE);
DOMNodeIterator* iter = doc->createNodeIterator(root, whatToShow, filter, true);
TASSERT(iter->getWhatToShow() == 1);
TASSERT(iter->getExpandEntityReferences() == 1);
DOMNode* nd;
nd = iter->nextNode();
TASSERT (nd ==root);
nd = iter->nextNode();
TASSERT (nd ==E11);
nd = iter->nextNode();
TASSERT(nd == E111);
nd = iter->nextNode();
TASSERT(nd == E112);
nd = iter->nextNode();
TASSERT(nd == E12);
nd = iter->nextNode();
TASSERT(nd == E121);
nd = iter->nextNode();
TASSERT(nd == E122);
nd = iter->nextNode();
TASSERT(nd == E13);
nd = iter->nextNode();
TASSERT(nd == E131);
nd = iter->previousNode();
TASSERT(nd == E131);
nd = iter->previousNode();
TASSERT(nd == E13);
nd = iter->previousNode();
TASSERT(nd == E122);
delete filter;
}
{
// Text node iterating test
DOMNode* node = doc->getFirstChild();
UNUSED(node); // silence warning
unsigned long whatToShow = DOMNodeFilter::SHOW_TEXT;
MyFilter* filter = new MyFilter(DOMNode::TEXT_NODE);
DOMNodeIterator* iter = ((DOMDocumentTraversal*)doc)->createNodeIterator(root, whatToShow, filter, true);
TASSERT(iter->getWhatToShow() == 4);
TASSERT(iter->getExpandEntityReferences() == 1);
DOMNode* nd;
nd = iter->nextNode();
TASSERT (nd ==textNode1);
nd = iter->nextNode();
TASSERT (nd ==textNode2);
nd = iter->previousNode();
TASSERT(nd == textNode2);
delete filter;
}
{
//CDataSection node itearating test
DOMNode* node = doc->getFirstChild();
UNUSED(node); // silence warning
unsigned long whatToShow = DOMNodeFilter::SHOW_CDATA_SECTION;
MyFilter* filter = new MyFilter(DOMNode::CDATA_SECTION_NODE);
DOMNodeIterator* iter = doc->createNodeIterator(root, whatToShow, filter, true);
TASSERT(iter->getWhatToShow() == 8);
TASSERT(iter->getExpandEntityReferences() == 1);
DOMNode* nd;
nd = iter->nextNode();
TASSERT(nd == cdataSec);
nd = iter->nextNode();
TASSERT(nd == 0);
delete filter;
}
{
// PI nodes iterating test
DOMNode* node = doc->getFirstChild();
UNUSED(node); // silence warning
unsigned long whatToShow = DOMNodeFilter::SHOW_PROCESSING_INSTRUCTION;
MyFilter* filter = new MyFilter(DOMNode::PROCESSING_INSTRUCTION_NODE);
DOMNodeIterator* iter = ((DOMDocumentTraversal*)doc)->createNodeIterator(root, whatToShow, filter, true);
TASSERT(iter->getWhatToShow() == 64);
TASSERT(iter->getExpandEntityReferences() == 1);
DOMNode* nd;
nd = iter->nextNode();
TASSERT(nd == docPI);
nd = iter->nextNode();
TASSERT(nd == 0);
delete filter;
}
{
DOMNode* node = doc->getFirstChild();
UNUSED(node); // silence warning
unsigned long whatToShow = DOMNodeFilter::SHOW_COMMENT;
MyFilter* filter = new MyFilter(DOMNode::COMMENT_NODE);
DOMNodeIterator* iter = doc->createNodeIterator(root, whatToShow, filter, true);
TASSERT(iter->getWhatToShow() == 128);
TASSERT(iter->getExpandEntityReferences() == 1);
DOMNode* nd;
nd = iter->nextNode();
TASSERT(nd == comment);
nd = iter->nextNode();
TASSERT(nd == 0);
delete filter;
}
////////// TreeWalker Test Cases ////////////////
{
unsigned long whatToShow = DOMNodeFilter::SHOW_ALL;
DOMTreeWalker* tw = ((DOMDocumentTraversal*)doc)->createTreeWalker(doc, whatToShow, 0, true);
TASSERT(tw->getCurrentNode() == doc);
TASSERT(tw->firstChild() == root);
TASSERT(tw->nextSibling() == 0);
TASSERT(tw->lastChild() == comment);
TASSERT(tw->firstChild() == 0);
TASSERT(tw->lastChild() == 0);
TASSERT(tw->nextSibling() == 0);
TASSERT(tw->nextNode() == 0);
TASSERT(tw->previousSibling() == E13);
TASSERT(tw->previousNode() == E122);
TASSERT(tw->parentNode() == E12);
TASSERT(tw->firstChild() == textNode2);
TASSERT(tw->previousSibling() == 0);
TASSERT(tw->nextSibling() == E121);
TASSERT(tw->nextNode() == E122);
TASSERT(tw->parentNode() == E12);
TASSERT(tw->previousSibling() == E11);
TASSERT(tw->previousNode() == root);
TASSERT(tw->previousNode() == doc);
TASSERT(tw->previousNode() == 0);
TASSERT(tw->parentNode() == 0);
TASSERT(tw->getCurrentNode() == doc);
}
{
MyFilter mf(DOMNode::ELEMENT_NODE);
unsigned long whatToShow = DOMNodeFilter::SHOW_ALL;
DOMTreeWalker* tw = doc->createTreeWalker(root, whatToShow, &mf, true);
TASSERT(tw->getCurrentNode() == root);
TASSERT(tw->parentNode() == 0); //should not change currentNode
TASSERT(tw->getCurrentNode() == root);
TASSERT(tw->nextNode() == E11);
TASSERT(tw->nextNode() == E111);
tw->setCurrentNode(E12);
//when first is not visible, should it go to its sibling?
TASSERT(tw->firstChild() == E121); //first visible child
TASSERT(tw->previousSibling() == 0);
}
{
MyFilter mf(DOMNode::ELEMENT_NODE, true);
unsigned long whatToShow = DOMNodeFilter::SHOW_ELEMENT;
DOMTreeWalker* tw = ((DOMDocumentTraversal*)doc)->createTreeWalker(root, whatToShow, &mf, true);
tw->setCurrentNode(E12);
TASSERT(tw->firstChild() == E121); //still first visible child
}
{
MyFilter mf(DOMNode::TEXT_NODE);
unsigned long whatToShow = DOMNodeFilter::SHOW_TEXT;
DOMTreeWalker* tw = doc->createTreeWalker(root, whatToShow, &mf, true);
//when first is not visible, should it go to its descendent?
TASSERT(tw->firstChild() == textNode1); //E11 skipped
TASSERT(tw->firstChild() == 0);
TASSERT(tw->nextNode() == textNode2);
TASSERT(tw->nextSibling() == 0);
TASSERT(tw->parentNode() == 0); //no visible ancestor
TASSERT(tw->getCurrentNode() == textNode2);
tw->setCurrentNode(root);
//when last is not visible, should it go to its sibling & descendent?
TASSERT(tw->lastChild() == textNode2); //last visible child
tw->setCurrentNode(E12);
//when next sibling is not visible, should it go to its descendent?
TASSERT(tw->nextSibling() == 0);
}
{
MyFilter mf(DOMNode::TEXT_NODE, true);
unsigned long whatToShow = DOMNodeFilter::SHOW_TEXT;
DOMTreeWalker* tw = ((DOMDocumentTraversal*)doc)->createTreeWalker(root, whatToShow, &mf, true);
TASSERT(tw->firstChild() == 0); //E11 rejected and no children is TEXT
TASSERT(tw->getCurrentNode() == root);
TASSERT(tw->nextNode() == 0); //E11 rejected so can't get to textNode1
//test getRoot
TASSERT(tw->getRoot() == root);
TASSERT(tw->getRoot() != doc);
}
doc->release();
};
// And call the termination method
XMLPlatformUtils::Terminate();
if (errorOccurred) {
printf("Test Failed\n");
return 4;
}
printf("Test Run Successfully\n");
return 0;
};
bool XmlWorldParser::process_xml(const char* xmlFile) {
try {
XMLPlatformUtils::Initialize();
} catch (const XMLException& toCatch) {
char* message = XMLString::transcode(toCatch.getMessage());
cout << "Error during initialization! :\n" << message << "\n";
XMLString::release(&message);
return 1;
}
XercesDOMParser* parser = new XercesDOMParser();
parser->setValidationScheme(XercesDOMParser::Val_Always);
parser->setDoNamespaces(true); // optional
/**
* Configure parser error handling
*/
ErrorHandler* errHandler = (ErrorHandler*) new HandlerBase();
// ErrorHandler *errHandler =(ErrorHandler*) new DOMPrintErrorHandler();
parser->setErrorHandler(errHandler);
try {
parser->parse(xmlFile);
} catch (const XMLException& toCatch) {
char* message = XMLString::transcode(toCatch.getMessage());
cout << "Exception message is: \n" << message << "\n";
XMLString::release(&message);
return -1;
} catch (const DOMException& toCatch) {
char* message = XMLString::transcode(toCatch.msg);
cout << "Exception message is: \n" << message << "\n";
XMLString::release(&message);
return -1;
} catch (const SAXException& toCatch) {
char* message = XMLString::transcode(toCatch.getMessage());
cout << "Exception message is: " << message << "\n";
XMLString::release(&message);
return -1;
} catch (const exception& toCatch) {
cout << "Unexpected Exception \n" << toCatch.what() << endl;
return -1;
}
/**
* Walk through the document, adding bodies and joints in their relative frames
*/
DOMDocument* doc = parser->getDocument();
DOMTreeWalker* walker = doc->createTreeWalker(doc->getDocumentElement(),
DOMNodeFilter::SHOW_ELEMENT, new BodiesInWorld(), true);
/** Initial world frame */
double transform[3] = { 0, 0, 0 };
processNode(walker, transform);
//TODO Ensure that I am cleaning up everything I need to
/** Clean up no longer needed resources **/
doc->release();
delete errHandler;
return true;
}
DOMText* DOMTextImpl::replaceWholeText(const XMLCh* newText)
{
DOMDocument *doc = getOwnerDocument();
DOMTreeWalker* pWalker=doc->createTreeWalker(doc->getDocumentElement(), DOMNodeFilter::SHOW_ALL, NULL, true);
pWalker->setCurrentNode((DOMNode*)this);
// Logically-adjacent text nodes are Text or CDATASection nodes that can be visited sequentially in document order or in
// reversed document order without entering, exiting, or passing over Element, Comment, or ProcessingInstruction nodes.
DOMNode* pFirstTextNode=this;
DOMNode* prevNode;
while((prevNode=pWalker->previousNode())!=NULL)
{
if(prevNode->getNodeType()==ELEMENT_NODE || prevNode->getNodeType()==COMMENT_NODE || prevNode->getNodeType()==PROCESSING_INSTRUCTION_NODE)
break;
pFirstTextNode=prevNode;
}
// before doing any change we need to check if we are going to remove an entity reference that doesn't contain just text
DOMNode* pCurrentNode=pWalker->getCurrentNode();
DOMNode* nextNode;
while((nextNode=pWalker->nextNode())!=NULL)
{
if(nextNode->getNodeType()==ELEMENT_NODE || nextNode->getNodeType()==COMMENT_NODE || nextNode->getNodeType()==PROCESSING_INSTRUCTION_NODE)
break;
if(nextNode->getNodeType()==ENTITY_REFERENCE_NODE)
{
DOMTreeWalker* pInnerWalker=doc->createTreeWalker(nextNode, DOMNodeFilter::SHOW_ALL, NULL, true);
while(pInnerWalker->nextNode())
{
short nodeType=pInnerWalker->getCurrentNode()->getNodeType();
if(nodeType!=ENTITY_REFERENCE_NODE && nodeType!=TEXT_NODE && nodeType!=CDATA_SECTION_NODE)
throw DOMException(DOMException::NO_MODIFICATION_ALLOWED_ERR, 0, GetDOMNodeMemoryManager);
}
pInnerWalker->release();
}
}
DOMText* retVal=NULL;
// if the first node in the chain is a text node, replace its content, otherwise create a new node
if(newText && *newText)
{
if(!castToNodeImpl(pFirstTextNode)->isReadOnly() && (pFirstTextNode->getNodeType()==TEXT_NODE || pFirstTextNode->getNodeType()==CDATA_SECTION_NODE))
{
pFirstTextNode->setNodeValue(newText);
retVal=(DOMText*)pFirstTextNode;
}
else
{
if(getNodeType()==TEXT_NODE)
retVal=doc->createTextNode(newText);
else
retVal=doc->createCDATASection(newText);
pFirstTextNode->getParentNode()->insertBefore(retVal, pFirstTextNode);
}
}
// now delete all the following text nodes
pWalker->setCurrentNode(pCurrentNode);
while((nextNode=pWalker->nextNode())!=NULL)
{
if(nextNode->getNodeType()==ELEMENT_NODE || nextNode->getNodeType()==COMMENT_NODE || nextNode->getNodeType()==PROCESSING_INSTRUCTION_NODE)
break;
if(nextNode!=retVal)
{
// keep the tree walker valid
pWalker->previousNode();
nextNode->getParentNode()->removeChild(nextNode);
nextNode->release();
}
}
pWalker->release();
return retVal;
}
/**
* Main routine that utilizes Xercesc module to create a DOM object in memory
* and prints out the resultant DOM structure
* @param argC number of command line args
* @param argV name of command line args
* @return 0 if no errors occurred
*/
int main(int argC, char*argv[]) {
// Initialize the XML4C2 system.
try {
XMLPlatformUtils::Initialize();
} catch (const XMLException& toCatch) {
char *pMsg = XMLString::transcode(toCatch.getMessage());
XERCES_STD_QUALIFIER cerr << "Error during Xerces-c Initialization.\n" << " Exception message:" << pMsg;
XMLString::release(&pMsg);
return 1;
}
// Watch for special case help request
int errorCode = 0;
if (argC > 1) {
XERCES_STD_QUALIFIER
cout << "\nUsage:\n"
" CreateDOMDocument\n\n"
"This program creates a new DOM document from scratch in memory.\n"
"It then prints the count of elements in the tree.\n" << XERCES_STD_QUALIFIER
endl;
errorCode = 1;
}
if (errorCode) {
XMLPlatformUtils::Terminate();
return errorCode;
}
DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(X("Core"));
if (impl != NULL) {
try {
// create a DomDocument instance
DOMDocument* doc = impl->createDocument(
0, // root element namespace URI.
X("TheHood"), // root element name
0); // document type object (DTD).
// create root attribute nodes
DOMAttr* woop_atr = doc->createAttribute(X("WOOP"));
woop_atr->setValue(X("DANG"));
DOMAttr* fiyah_atr = doc->createAttribute(X("FIYAH"));
fiyah_atr->setValue(X("hot"));
DOMAttr* hungry_atr = doc->createAttribute(X("hungry"));
hungry_atr->setValue(X("starving"));
// create root element
DOMElement* rootElem = doc->getDocumentElement();
// set root attrs
rootElem->setAttributeNode(woop_atr);
rootElem->setAttributeNode(fiyah_atr);
rootElem->setAttributeNode(hungry_atr);
//create root child elements
DOMElement* gangElem = doc->createElement(X("gang"));
rootElem->appendChild(gangElem);
DOMText* gangDataVal = doc->createTextNode(X("YoungThugz"));
gangElem->appendChild(gangDataVal);
gangElem->setAttribute(X("hardness"), X("rock"));
//create gang attr nodes
DOMAttr* members_atr = doc->createAttribute(X("members"));
members_atr->setValue(X("500"));
DOMAttr* color_atr = doc->createAttribute(X("color"));
color_atr->setValue(X("magenta"));
// set gang attr
gangElem->setAttributeNode(members_atr);
gangElem->setAttributeNode(color_atr);
// create gang elem children
DOMElement* piruElem = doc->createElement(X("piru"));
piruElem->setNodeValue(X("w"));
DOMElement* cripElem = doc->createElement(X("crip"));
cripElem->setNodeValue(X("t"));
DOMElement* trgElem = doc->createElement(X("trg"));
trgElem->setNodeValue(X("o"));
// append gang elem children
gangElem->appendChild(piruElem);
gangElem->appendChild(cripElem);
gangElem->appendChild(trgElem);
DOMElement* turfElem = doc->createElement(X("turf"));
rootElem->appendChild(turfElem);
turfElem->setAttribute(X("idea"), X("great"));
DOMText* turfDataVal = doc->createTextNode(X("West Side Projects"));
turfElem->appendChild(turfDataVal);
DOMElement* cliqueElem = doc->createElement(X("clique"));
rootElem->appendChild(cliqueElem);
DOMText* cliqueDataVal = doc->createTextNode(X("Balla$"));
cliqueElem->appendChild(cliqueDataVal);
cliqueElem->setAttribute(X("Comradery"), X("tight"));
DOMElement* sideElem = doc->createElement(X("side"));
rootElem->appendChild(sideElem);
DOMText* sideDataVal = doc->createTextNode(X("North North"));
sideElem->appendChild(sideDataVal);
// create side elem children
DOMElement* tempElem = doc->createElement(X("temperature"));
tempElem->setNodeValue(X("100 C"));
DOMElement* med_incomeElem = doc->createElement(X("medianIncome"));
med_incomeElem->setNodeValue(X("$20,000"));
DOMElement* schoolsElem = doc->createElement(X("schools"));
schoolsElem->setNodeValue(X("Regional"));
// append side elem children
sideElem->appendChild(tempElem);
sideElem->appendChild(med_incomeElem);
sideElem->appendChild(schoolsElem);
DOMElement* gatElem = doc->createElement(X("gat"));
rootElem->appendChild(gatElem);
DOMText* gatDataVal = doc->createTextNode(X("Glock"));
gatElem->appendChild(gatDataVal);
//set gat attr
gatElem->setAttribute(X("caliber"), X(".50"));
// create gat elem children
DOMElement* rifleElem = doc->createElement(X("rifle"));
DOMElement* meleeElem = doc->createElement(X("melee"));
DOMElement* pieceElem = doc->createElement(X("piece"));
// append gat elem children
gatElem->appendChild(rifleElem);
gatElem->appendChild(meleeElem);
gatElem->appendChild(pieceElem);
DOMElement* contraElem = doc->createElement(X("contra"));
rootElem->appendChild(contraElem);
DOMText* contraDataVal = doc->createTextNode(X("Cocoa"));
contraElem->appendChild(contraDataVal);
contraElem->setAttribute(X("rareness"), X("extreme"));
// create contra elem children
DOMElement* methElem = doc->createElement(X("meth"));
DOMElement* ganjaElem = doc->createElement(X("ganja"));
DOMElement* ethElem = doc->createElement(X("ethanol"));
// append contra elem children
contraElem->appendChild(methElem);
contraElem->appendChild(ganjaElem);
contraElem->appendChild(ethElem);
//create contra attr nodes
DOMAttr* price_atr = doc->createAttribute(X("price"));
price_atr->setValue(X("$25"));
DOMAttr* source_atr = doc->createAttribute(X("source"));
source_atr->setValue(X("Columbia"));
// set contra attr
contraElem->setAttributeNode(price_atr);
contraElem->setAttributeNode(source_atr);
DOMElement* rivalsElem = doc->createElement(X("rivals"));
rootElem->appendChild(rivalsElem);
DOMText* rivalsDataVal = doc->createTextNode(X("Warrriors"));
rivalsElem->appendChild(rivalsDataVal);
DOMElement* policeElem = doc->createElement(X("police"));
rootElem->appendChild(policeElem);
DOMText* policeDataVal = doc->createTextNode(X("popo"));
policeElem->appendChild(policeDataVal);
DOMElement* drugsElem = doc->createElement(X("drugs"));
rootElem->appendChild(drugsElem);
DOMText* drugsDataVal = doc->createTextNode(X("codiene"));
drugsElem->appendChild(drugsDataVal);
// create drugs elem children
DOMElement* mixElem = doc->createElement(X("mix"));
DOMElement* spriteElem = doc->createElement(X("sprite"));
DOMElement* leanElem = doc->createElement(X("lean"));
// append drugs elem children
drugsElem->appendChild(mixElem);
drugsElem->appendChild(spriteElem);
drugsElem->appendChild(leanElem);
DOMElement* crimeElem = doc->createElement(X("crime"));
rootElem->appendChild(crimeElem);
DOMText* crimeDataVal = doc->createTextNode(X("187"));
crimeElem->appendChild(crimeDataVal);
//
// Now count the number of elements in the above DOM tree.
//
const XMLSize_t elementCount = doc->getElementsByTagName(X("*"))->getLength();
XERCES_STD_QUALIFIER cout << "The tree just created contains: " << elementCount
<< " elements." << XERCES_STD_QUALIFIER endl;
// create serializer instance
DOMLSSerializer *theSerializer = ((DOMImplementationLS*) impl)->createLSSerializer();
// create output instance
DOMLSOutput *theOutputDesc = ((DOMImplementationLS*) impl)->createLSOutput();
// referenced the following http://stackoverflow.com/questions/2897317/writing-xml-with-xerces-3-0-1-and-c-on-windows
// set output from serializer to stdout
XMLFormatTarget *myFormTarget;
myFormTarget = new StdOutFormatTarget();
theOutputDesc->setByteStream(myFormTarget);
// Make the output more human readable by inserting line feeds.
if (theSerializer->getDomConfig()->canSetParameter(XMLUni::fgDOMWRTFormatPrettyPrint, true))
theSerializer->getDomConfig()->setParameter(XMLUni::fgDOMWRTFormatPrettyPrint, true);
// The end-of-line sequence of characters to be used in the XML being written out.
theSerializer->setNewLine(XMLString::transcode("\r\n"));
// output the DOM
theSerializer->write(doc, theOutputDesc);
cout << endl << endl << "*****************************************" << endl;
// Using DOMTreeWalker class to traverse tree
// create tree walker
DOMTreeWalker* walker = doc->createTreeWalker(rootElem,
DOMNodeFilter::SHOW_ELEMENT,
NULL,
true);
// create vector to hold Dom nodes
vector<DOMNode*> elem_vec;
// traverse tree using walker
for (DOMNode* current = walker->nextNode(); current != 0; current = walker->nextNode()) {
// store nodes int vector
elem_vec.push_back(current);
}
// sort function - alphabetically elements
std::sort(elem_vec.begin(), elem_vec.end(), compare_elem_alpha);
// iterate through sorted nodes
for (auto i : elem_vec) {
int x;
string text = string(x(i->getTextContent()));
cout << "Node Name: " << x(i->getNodeName()) << ((text != "") ? " |Text Content: " + text : "") << endl;
//get attr map
if (i->hasAttributes()) {
DOMNamedNodeMap *attr_map = i->getAttributes();
// get each node in the map
for (x = 0; x < attr_map->getLength(); x++) {
DOMNode *temp = attr_map->item(x);
cout << setw(5) << "" << "Attribute" << x + 1 << ": " << x(temp->getNodeName()) << " = "
<< x(temp->getNodeValue()) << endl;
}
}
}
// release doc resources
doc->release();
} catch (const OutOfMemoryException&) {
XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl;
errorCode = 5;
} catch (const DOMException& e) {
XERCES_STD_QUALIFIER cerr << "DOMException code is: " << e.code << XERCES_STD_QUALIFIER endl;
errorCode = 2;
} catch (...) {
XERCES_STD_QUALIFIER cerr << "An error occurred creating the document" << XERCES_STD_QUALIFIER endl;
errorCode = 3;
}
}// (impl != NULL)
else {
XERCES_STD_QUALIFIER cerr << "Requested implementation is not supported" << XERCES_STD_QUALIFIER endl;
errorCode = 4;
}
}
bool ServerConfigXMLReader::readServerConfig(const std::string & path) {
this->serverConfig = ServerConfig();
try {
XMLPlatformUtils::Initialize();
} catch (const XMLException& toCatch) {
char * message = XMLString::transcode(toCatch.getMessage());
cout << "Error during initialization! :\n" << message << "\n";
XMLString::release(&message);
return false;
}
XercesDOMParser * parser = new XercesDOMParser();
//parser->setValidationScheme(XercesDOMParser::Val_Auto);
parser->setDoNamespaces(true);
parser->setDoXInclude(true);
//parser->setValidationScheme(XercesDOMParser::Val_Always);
// parser->setDoSchema(true);
// parser->setValidationSchemaFullChecking(true);
XMLParseErrorReporter * xmlParseErrorReporter = new XMLParseErrorReporter();;
parser->setErrorHandler(xmlParseErrorReporter);
try {
parser->parse(path.c_str());
} catch (const XMLException & toCatch) {
char * message = XMLString::transcode(toCatch.getMessage());
cout << "Exception message is: \n" << message << "\n";
XMLString::release(&message);
return false;
}
catch (const DOMException& toCatch) {
char * message = XMLString::transcode(toCatch.msg);
cout << "Exception message is: \n" << message << "\n";
XMLString::release(&message);
return false;
}
catch (...) {
cout << "Unexpected Exception \n" ;
return false;
}
DOMDocument * domDocument = parser->getDocument();
removeBaseAttr(domDocument);
// get a serializer, an instance of DOMLSSerializer
XMLCh tempStr[3] = {chLatin_L, chLatin_S, chNull};
DOMImplementation *impl = DOMImplementationRegistry::getDOMImplementation(tempStr);
DOMLSSerializer *theSerializer = ((DOMImplementationLS*)impl)->createLSSerializer();
DOMLSOutput *theOutputDesc = ((DOMImplementationLS*)impl)->createLSOutput();
// set user specified output encoding
theOutputDesc->setEncoding(0);
XMLDOMErrorReporter * xmlDOMErrorReporter = new XMLDOMErrorReporter();
DOMConfiguration * serializerConfig = theSerializer->getDomConfig();
serializerConfig->setParameter(XMLUni::fgDOMErrorHandler, xmlDOMErrorReporter);
// set feature if the serializer supports the feature/mode
if (serializerConfig->canSetParameter(XMLUni::fgDOMWRTSplitCdataSections, true))
serializerConfig->setParameter(XMLUni::fgDOMWRTSplitCdataSections, true);
if (serializerConfig->canSetParameter(XMLUni::fgDOMWRTDiscardDefaultContent, true))
serializerConfig->setParameter(XMLUni::fgDOMWRTDiscardDefaultContent, true);
if (serializerConfig->canSetParameter(XMLUni::fgDOMWRTFormatPrettyPrint, false))
serializerConfig->setParameter(XMLUni::fgDOMWRTFormatPrettyPrint, false);
if (serializerConfig->canSetParameter(XMLUni::fgDOMWRTBOM, false))
serializerConfig->setParameter(XMLUni::fgDOMWRTBOM, false);
/*
XMLFormatTarget * myFormTarget = new StdOutFormatTarget();
theOutputDesc->setByteStream(myFormTarget);
theSerializer->write(domDocument, theOutputDesc);
*/
MemBufFormatTarget * myFormTarget = new MemBufFormatTarget();
theOutputDesc->setByteStream(myFormTarget);
theSerializer->write(domDocument, theOutputDesc);
/*
XMLFormatTarget * myFormTarget2 = new StdOutFormatTarget();
theOutputDesc->setByteStream(myFormTarget2);
theSerializer->write(domDocument, theOutputDesc);
*/
MemBufInputSource * memInput = new MemBufInputSource(myFormTarget->getRawBuffer(), myFormTarget->getLen(), path.c_str());
XercesDOMParser * parser2 = new XercesDOMParser();
parser2->setDoNamespaces(true);
parser2->setDoXInclude(true);
// parser2->setValidationScheme(XercesDOMParser::Val_Always);
// parser2->setDoSchema(true);
// parser2->setValidationSchemaFullChecking(true);
parser2->setErrorHandler(xmlParseErrorReporter);
try {
parser2->parse(*memInput);
} catch (const XMLException & toCatch) {
char * message = XMLString::transcode(toCatch.getMessage());
cout << "Exception message is: \n" << message << "\n";
XMLString::release(&message);
return false;
}
catch (const DOMException& toCatch) {
char * message = XMLString::transcode(toCatch.msg);
cout << "Exception message is: \n" << message << "\n";
XMLString::release(&message);
return false;
}
catch (...) {
cout << "Unexpected Exception \n" ;
return false;
}
DOMDocument * domDocument2 = parser2->getDocument();
XMLNodeFilter * xmlNodeFilter = new XMLNodeFilter();
DOMTreeWalker * domTreeWalker = domDocument->createTreeWalker(domDocument2, DOMNodeFilter::SHOW_ALL, xmlNodeFilter, true);
this->serverConfig = extractServerConfig(domDocument2, domTreeWalker);
domTreeWalker->release();
delete xmlNodeFilter;
delete xmlDOMErrorReporter;
delete xmlParseErrorReporter;
delete parser;
XMLPlatformUtils::Terminate();
return true;
}
