static Connector extractConnector(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) {
Connector connector;
DOMNode * node = domTreeWalker->getCurrentNode();
while (node) {
if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "SrcAddress") == 0) {
XMLNodeFilter * nodeFilter = new XMLNodeFilter();
DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true);
PortAddress portAddress = extractPortAddress(domDocument, d);
connector.setSrcAddress(portAddress);
d->release();
delete nodeFilter;
}
if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "DstAddress") == 0) {
XMLNodeFilter * nodeFilter = new XMLNodeFilter();
DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true);
PortAddress portAddress = extractPortAddress(domDocument, d);
connector.setDstAddress(portAddress);
d->release();
delete nodeFilter;
}
node = domTreeWalker->nextNode();
}
return connector;
}
static TUIObjectType extractTUIObjectType(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) {
TUIObjectType tuiObjectType;
DOMNode * node = domTreeWalker->getCurrentNode();
DOMNamedNodeMap * nodeMap = node->getAttributes();
DOMNode * nameAttribute = nodeMap->getNamedItem(XMLString::transcode("name"));
if (nameAttribute) {
tuiObjectType.setName(XMLString::transcode(nameAttribute->getNodeValue()));
}
while (node) {
if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "PortTypeSequence") == 0) {
XMLNodeFilter * nodeFilter = new XMLNodeFilter();
DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true);
tuiObjectType.setPortMap(extractPortMap(domDocument, d));
d->release();
delete nodeFilter;
} else if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "Description") == 0) {
XMLCh * textContent = XMLString::replicate(node->getTextContent());
XMLString::trim(textContent);
tuiObjectType.setDescription(XMLString::transcode(textContent));
XMLString::release(&textContent);
}
node = domTreeWalker->nextNode();
}
return tuiObjectType;
}
/**
* client::type getClientName( xercesc::DOMDocument* source )
*
* Extract information about the origin of the source document.
*
* @return The enumulator indicating the type of client.
* @param source A pointer to the DOMDocument tree containing the client information.
*/
static client::type getClientName( xercesc::DOMDocument* source )
{
DOMElement * root = source->getDocumentElement();
DOMTreeWalker * walker = source->createTreeWalker( root,
DOMNodeFilter::SHOW_ELEMENT,
NULL,
false );
const XMLCh * c = walker->firstChild()->getNodeName();
if( XMLString::equals( c, XMLString::transcode("nonmem") ) )
return client::NONMEM;
return client::NOT_SUPPORTED;
}
static MSPInstance extractMSPInstance(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) {
MSPInstance mspInstance;
map<string, ParameterGroup> parameterGroupMap;
DOMNode * node = domTreeWalker->getCurrentNode();
DOMNamedNodeMap * nodeMap = node->getAttributes();
DOMNode * nameAttribute = nodeMap->getNamedItem(XMLString::transcode("name"));
if (nameAttribute) {
mspInstance.setName(XMLString::transcode(nameAttribute->getNodeValue()));
}
DOMNode * typeNameAttribute = nodeMap->getNamedItem(XMLString::transcode("typename"));
if (typeNameAttribute) {
//TFDEBUG(XMLString::transcode(typeNameAttribute->getNodeValue()));
mspInstance.setTypeName(XMLString::transcode(typeNameAttribute->getNodeValue()));
}
while (node) {
if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "ParameterGroup") == 0) {
DOMNamedNodeMap * nodeMap = node->getAttributes();
string name;
DOMNode * nameAttribute = nodeMap->getNamedItem(XMLString::transcode("name"));
if (nameAttribute) {
name = XMLString::transcode(nameAttribute->getNodeValue());
}
XMLNodeFilter * nodeFilter = new XMLNodeFilter();
DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true);
ParameterGroup pg = extractParameterGroup(domDocument, d);
pg.setName(name);
parameterGroupMap[name] = pg;
d->release();
delete nodeFilter;
} else if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "Description") == 0) {
XMLCh * textContent = XMLString::replicate(node->getTextContent());
XMLString::trim(textContent);
mspInstance.setDescription(XMLString::transcode(textContent));
XMLString::release(&textContent);
}
node = domTreeWalker->nextNode();
}
ParameterGroup parameterGroup;
parameterGroup.setName("root");
parameterGroup.setParameterGroupMap(parameterGroupMap);
mspInstance.setParameterGroup(parameterGroup);
return mspInstance;
}
static ParameterGroup extractParameterGroup(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) {
map<string, string> parameterMap;
map<string, ParameterGroup> parameterGroupMap;
DOMNode * node = domTreeWalker->nextNode();
while (node) {
if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "Parameter") == 0) {
DOMNamedNodeMap * nodeMap = node->getAttributes();
string name;
DOMNode * nameAttribute = nodeMap->getNamedItem(XMLString::transcode("name"));
if (nameAttribute) {
name = XMLString::transcode(nameAttribute->getNodeValue());
}
string value;
DOMNode * valueAttribute = nodeMap->getNamedItem(XMLString::transcode("value"));
if (valueAttribute) {
value = XMLString::transcode(valueAttribute->getNodeValue());
}
parameterMap[name] = value;
//TFINFO("Parameter: " << name << " -> " << value);
} else if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "ParameterGroup") == 0) {
DOMNamedNodeMap * nodeMap = node->getAttributes();
string name;
DOMNode * nameAttribute = nodeMap->getNamedItem(XMLString::transcode("name"));
if (nameAttribute) {
name = XMLString::transcode(nameAttribute->getNodeValue());
}
XMLNodeFilter * nodeFilter = new XMLNodeFilter();
DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true);
ParameterGroup pg = extractParameterGroup(domDocument, d);
pg.setName(name);
parameterGroupMap[name] = pg;
d->release();
delete nodeFilter;
}
node = domTreeWalker->nextNode();
}
ParameterGroup parameterGroup;
parameterGroup.setParameterMap(parameterMap);
parameterGroup.setParameterGroupMap(parameterGroupMap);
return parameterGroup;
}
static vector<Connector> extractConnectorVector(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) {
vector<Connector> connectorVector;
DOMNode * node = domTreeWalker->getCurrentNode();
while (node) {
if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "Connector") == 0) {
XMLNodeFilter * nodeFilter = new XMLNodeFilter();
DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true);
Connector connector = extractConnector(domDocument, d);
connectorVector.push_back(connector);
d->release();
delete nodeFilter;
}
node = domTreeWalker->nextNode();
}
return connectorVector;
}
static map<string, TUIObjectType> extractTUIObjectTypeMap(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) {
map<string, TUIObjectType> tuiObjectTypeMap;
DOMNode * node = domTreeWalker->getCurrentNode();
while (node) {
if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "TUIObjectType") == 0) {
XMLNodeFilter * nodeFilter = new XMLNodeFilter();
DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true);
TUIObjectType tuiObjectType = extractTUIObjectType(domDocument, d);
tuiObjectTypeMap[tuiObjectType.getName()] = tuiObjectType;
d->release();
delete nodeFilter;
}
node = domTreeWalker->nextNode();
}
return tuiObjectTypeMap;
}
static DeviceInstance extractDeviceInstance(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) {
DeviceInstance deviceInstance;
map<string, ParameterGroup> parameterGroupMap;
DOMNode * node = domTreeWalker->getCurrentNode();
DOMNamedNodeMap * nodeMap = node->getAttributes();
DOMNode * nameAttribute = nodeMap->getNamedItem(XMLString::transcode("name"));
if (nameAttribute) {
deviceInstance.setName(XMLString::transcode(nameAttribute->getNodeValue()));
}
DOMNode * typenameAttribute = nodeMap->getNamedItem(XMLString::transcode("typename"));
if (typenameAttribute) {
deviceInstance.setDeviceTypeName(XMLString::transcode(typenameAttribute->getNodeValue()));
}
while (node) {
if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "ParameterGroup") == 0) {
DOMNamedNodeMap * nodeMap = node->getAttributes();
string name;
DOMNode * nameAttribute = nodeMap->getNamedItem(XMLString::transcode("name"));
if (nameAttribute) {
name = XMLString::transcode(nameAttribute->getNodeValue());
}
XMLNodeFilter * nodeFilter = new XMLNodeFilter();
DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true);
ParameterGroup pg = extractParameterGroup(domDocument, d);
pg.setName(name);
parameterGroupMap[name] = pg;
d->release();
delete nodeFilter;
}
node = domTreeWalker->nextNode();
}
ParameterGroup parameterGroup;
parameterGroup.setName("root");
parameterGroup.setParameterGroupMap(parameterGroupMap);
deviceInstance.setParameterGroup(parameterGroup);
return deviceInstance;
}
static map<string, MSPInstance> extractMSPInstanceMap(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) {
map<string, MSPInstance> mspInstanceMap;
DOMNode * node = domTreeWalker->getCurrentNode();
while (node) {
if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "MSPInstance") == 0) {
XMLNodeFilter * nodeFilter = new XMLNodeFilter();
DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true);
MSPInstance mspInstance = extractMSPInstance(domDocument, d);
mspInstanceMap[mspInstance.getName()] = mspInstance;
d->release();
delete nodeFilter;
}
node = domTreeWalker->nextNode();
}
return mspInstanceMap;
}
static map<string, Port> extractPortMap(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) {
map<string, Port> portMap;
DOMNode * node = domTreeWalker->getCurrentNode();
while (node) {
if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "PortType") == 0) {
XMLNodeFilter * nodeFilter = new XMLNodeFilter();
DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true);
Port port = extractPort(domDocument, d);
portMap[port.getName()] = port;
d->release();
delete nodeFilter;
}
node = domTreeWalker->nextNode();
}
return portMap;
}
static map<string, Connector> extractConnectorMap(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) {
map<string, Connector> connectorMap;
DOMNode * node = domTreeWalker->getCurrentNode();
while (node) {
if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "Connector") == 0) {
XMLNodeFilter * nodeFilter = new XMLNodeFilter();
DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true);
Connector connector = extractConnector(domDocument, d);
// TODO extractConnectorMap
//connectorMap[connector.getChannel2Name()] = connector;
d->release();
delete nodeFilter;
}
node = domTreeWalker->nextNode();
}
return connectorMap;
}
static void removeBaseAttr(DOMDocument * domDocument) {
XMLNodeFilter * nodeFilter = new XMLNodeFilter();
DOMTreeWalker * domTreeWalker = domDocument->createTreeWalker(domDocument, DOMNodeFilter::SHOW_ALL, nodeFilter, true);
DOMNode * node = domTreeWalker->getCurrentNode();
while (node) {
DOMNamedNodeMap * nodeMap = node->getAttributes();
if (nodeMap != 0) {
DOMNode * attr = nodeMap->getNamedItem(XMLString::transcode("xml:base"));
if (attr) {
DOMNode * node = nodeMap->removeNamedItem(XMLString::transcode("xml:base"));
TFINFO("[Server Config] filtered attribute: " << XMLString::transcode(node->getNodeName()) << "=" << XMLString::transcode(node->getNodeValue()));
node->release();
}
}
node = domTreeWalker->nextNode();
}
delete nodeFilter;
}
static DeviceType extractDeviceType(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) {
DeviceType deviceType;
DOMNode * node = domTreeWalker->getCurrentNode();
while (node) {
if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "PortTypeSequence") == 0) {
XMLNodeFilter * nodeFilter = new XMLNodeFilter();
DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true);
deviceType.setPortMap(extractPortMap(domDocument, d));
d->release();
delete nodeFilter;
} else if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "Description") == 0) {
XMLCh * textContent = XMLString::replicate(node->getTextContent());
XMLString::trim(textContent);
deviceType.setDescription(XMLString::transcode(textContent));
XMLString::release(&textContent);
}
node = domTreeWalker->nextNode();
}
return deviceType;
}
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;
};
/**
* 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;
}
static ServerConfig extractServerConfig(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) {
ServerConfig serverConfig;
DOMNode * node = domTreeWalker->getCurrentNode();
while (node) {
if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "ServerStartupConfig") == 0) {
XMLNodeFilter * nodeFilter = new XMLNodeFilter();
DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true);
serverConfig.setServerStartupConfig(extractServerStartupConfig(domDocument, d));
d->release();
delete nodeFilter;
} else if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "DeviceTypeSequence") == 0) {
XMLNodeFilter * nodeFilter = new XMLNodeFilter();
DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true);
serverConfig.setDeviceTypeMap(extractDeviceTypeMap(domDocument, d));
d->release();
delete nodeFilter;
} else if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "DeviceInstanceSequence") == 0) {
XMLNodeFilter * nodeFilter = new XMLNodeFilter();
DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true);
serverConfig.setDeviceInstanceMap(extractDeviceInstanceMap(domDocument, d));
d->release();
delete nodeFilter;
} else if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "TUIObjectTypeSequence") == 0) {
XMLNodeFilter * nodeFilter = new XMLNodeFilter();
DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true);
serverConfig.setTUIObjectTypeMap(extractTUIObjectTypeMap(domDocument, d));
d->release();
delete nodeFilter;
} else if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "TUIObjectInstanceSequence") == 0) {
XMLNodeFilter * nodeFilter = new XMLNodeFilter();
DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true);
serverConfig.setTUIObjectInstanceMap(extractTUIObjectInstanceMap(domDocument, d));
d->release();
delete nodeFilter;
} else if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "ConnectorSequence") == 0) {
XMLNodeFilter * nodeFilter = new XMLNodeFilter();
DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true);
serverConfig.setConnectorVector(extractConnectorVector(domDocument, d));
d->release();
delete nodeFilter;
} else if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "MSPTypeSequence") == 0) {
XMLNodeFilter * nodeFilter = new XMLNodeFilter();
DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true);
//serverConfig.setMSPTypeMap(extractMSPTypeMap(domDocument, d));
d->release();
delete nodeFilter;
} else if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "MSPInstanceSequence") == 0) {
XMLNodeFilter * nodeFilter = new XMLNodeFilter();
DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true);
serverConfig.setMSPInstanceMap(extractMSPInstanceMap(domDocument, d));
d->release();
delete nodeFilter;
}
node = domTreeWalker->nextNode();
}
return serverConfig;
}
