void EntityXMLFileWriter::WriteEntity(World* world, EntityID entity) { using namespace xercesc; DOMDocument* doc = m_DOMImplementation->createDocument(nullptr, X("Entity"), nullptr); DOMElement* root = doc->getDocumentElement(); root->setAttribute(X("xmlns:xsi"), X("http://www.w3.org/2001/XMLSchema-instance")); root->setAttribute(X("xsi:noNamespaceSchemaLocation"), X("../Types/Entity.xsd")); root->setAttribute(X("xmlns:c"), X("components")); const std::string& name = world->GetName(entity); if (!name.empty()) { root->setAttribute(X("name"), X(name)); } DOMElement* componentsElement = doc->createElement(X("Components")); root->appendChild(componentsElement); appentEntityComponents(componentsElement, world, entity); DOMElement* childrenElement = doc->createElement(X("Children")); root->appendChild(childrenElement); appendEntityChildren(childrenElement, world, entity); try { LocalFileFormatTarget* target = new LocalFileFormatTarget(X(m_FilePath.string())); DOMLSOutput* output = static_cast<DOMImplementationLS*>(m_DOMImplementation)->createLSOutput(); output->setByteStream(target); m_DOMLSSerializer->write(doc, output); delete target; } catch (const std::runtime_error& e) { LOG_ERROR("Failed to save \"%s\": %s", m_FilePath.c_str(), e.what()); } doc->release(); }
void EntityXMLFileWriter::appendEntityChildren(xercesc::DOMElement* parentElement, const World* world, EntityID entity) { using namespace xercesc; DOMDocument* doc = parentElement->getOwnerDocument(); auto childrenRange = world->GetEntityChildren().equal_range(entity); for (auto it = childrenRange.first; it != childrenRange.second; ++it) { EntityID childEntity = it->second; DOMElement* entityElement = doc->createElement(X("Entity")); const std::string& name = world->GetName(childEntity); if (!name.empty()) { entityElement->setAttribute(X("name"), X(name)); } parentElement->appendChild(entityElement); DOMElement* componentsElement = doc->createElement(X("Components")); entityElement->appendChild(componentsElement); appentEntityComponents(componentsElement, world, childEntity); DOMElement* childrenElement = doc->createElement(X("Children")); entityElement->appendChild(childrenElement); appendEntityChildren(childrenElement, world, childEntity); } }
void appendElementWithText( DOMNode* cur, DOMNode* reply, const char* name, const char* text, int indentLevel, bool indent, attrVect* attribute ) { MC2String indentStr( indentLevel*3, ' ' ); indentStr.insert( 0, "\n" ); DOMDocument* doc = XMLTool::getOwner( reply ); DOMElement* textElement = doc->createElement( X( name ) ); if ( text != NULL ) { textElement->appendChild( doc->createTextNode( X( text ) ) ); } if ( attribute != NULL ) { for ( uint32 i = 0 ; i < attribute->size() ; ++i ) { textElement->setAttribute( X( (*attribute)[ i ].first ), X( (*attribute)[ i ].second ) ); } } // Add textElement to cur if ( indent ) { cur->appendChild( doc->createTextNode( X( indentStr.c_str() ) ) ); } cur->appendChild( textElement ); }
void EppResponseInfoFeeType::toXMLCommon( DOMDocument &doc, const DOMString &tag, DOMElement& inElement ) { EppCommandInfoFeeType::toXMLCommon(doc, tag, inElement); DOMElement* elm = NULL; if( NULL != this->fee ) { for( unsigned int i = 0; i < fee->size(); i++ ) { EppFeeFee* member = fee->elementAt(i); if( NULL != member ) { elm = member->toXML(doc, "fee"); if( NULL != elm ) { inElement.appendChild(elm); } } } } if( this->fClass.length() > 0 ) { elm = doc.createElement(XS("class")); elm->appendChild(doc.createTextNode(this->fClass)); inElement.appendChild(elm); } }
XmlNode addChild(const char *name) { XMLCh *tempStr = NULL; tempStr = XMLString::transcode(name); DOMElement *element = doc->createElement(tempStr); DOMNode *cnode = node->appendChild(element); XMLString::release(&tempStr); return XmlNode(cnode,doc); }
// 2006/12/16 void handleFile(char* filein, char* fileout, int mode) { if (mode==_TXT2TXTMODE) { int result; if (filein == NULL) { if (fileout == NULL) result = seg->segmentStream(cin,cout); else { ofstream* fout = new ofstream(fileout); result = seg->segmentStream(cin,*fout); fout->close(); } } else { ifstream* fin = new ifstream(filein); ofstream* fout = new ofstream(fileout); result = seg->segmentStream(*fin,*fout); fin->close(); fout->close(); } // BROKEN, result is false 2006/11/07 //if (verbose) // cerr << "> Segmented in " << result << " sentences." << endl; } else if (mode==_TXT2XMLMODE) { DOMDocument* out = xmlInterface->createDocument("document"); DOMElement* root = out->getDocumentElement(); if (filein != NULL) root->setAttribute(XMLString::transcode("filename"), XMLString::transcode(filein)); DOMElement* contents = out->createElement(XMLString::transcode("content")); DOMElement* body = out->createElement(XMLString::transcode("body")); DOMElement* section = out->createElement(XMLString::transcode("section")); section->setAttribute(XMLString::transcode("analyze"), XMLString::transcode("yes")); DOMText* text = out->createTextNode(XMLString::transcode(getFileContents(filein).c_str())); section->appendChild(text); body->appendChild(section); contents->appendChild(body); root->appendChild(contents); handleDocument(out,fileout); } else if (mode==_XML2XMLMODE) { handleDocument(xmlInterface->parse(filein),fileout); } }
void EppCommandCheckFeeType::toXMLCommon( DOMDocument &doc, const DOMString &tag, DOMElement& inElement ) { DOMElement* elm = NULL; if( this->name.length() > 0 ) { elm = doc.createElement(XS("name")); elm->appendChild(doc.createTextNode(this->name)); inElement.appendChild(elm); } EppCommandInfoFeeType::toXMLCommon(doc, tag, inElement); }
XmlNode addChild(const char *name, const char *value) { XMLCh *tempStr = NULL; tempStr = XMLString::transcode(name); DOMElement *element = doc->createElement(tempStr); DOMNode *cnode = node->appendChild(element); if (value != NULL) { tempStr = XMLString::transcode(value); element->setTextContent(tempStr); } XMLString::release(&tempStr); return XmlNode(cnode,doc); }
// // set_element_value // void Utils:: set_element_value (xercesc::DOMElement * e, const GAME::Xml::String & element, const GAME::Xml::String & value) { using xercesc::DOMNode; using xercesc::DOMNodeList; using xercesc::DOMDocument; // There should be only 1 <name> tag in the list. GAME::Xml::String nodename; DOMNode * node = 0; DOMNodeList * list = e->getChildNodes (); size_t len = list->getLength (); for (size_t i = 0; i < len; ++ i) { // Get the name of the next node. node = list->item (i); nodename.set (node->getNodeName (), false); if (nodename == element) break; // Reset the node. node = 0; } if (node == 0) { // We need to create the <name> element. DOMDocument * doc = e->getOwnerDocument (); node = doc->createElement (element); e->appendChild (node); } // Since there are no child nodes, we can just set the // text content to the name of the object. node->setTextContent (value); }
PerfPart::PerfPart( PMLDocument *doc, ScorePart *part ){ m_doc = doc; DOMDocument *domdoc = part->getElement()->getOwnerDocument(); m_scorePart = part; m_element = domdoc->createElement( XS("perfpart") ); //'perfpart' tag is the m_element for this class //create part attribute m_element->setAttribute( XS("part"), XS( m_scorePart->getID().c_str() ) ); //append part to performance element DOMElement *perf = (DOMElement*)domdoc->getElementsByTagName(XS("performance"))->item(0); perf->appendChild( m_element ); DOMNodeList *nl = m_element->getElementsByTagName(XS(PNote::Tag)); for( int i=0; i<nl->getLength(); i++ ){ m_notes.push_back( new PNote( m_doc, (DOMElement*)nl->item(i) ) ); } }
void SNote::align( PNote *note, bool correct ){ DOMNodeList *list = m_element->getElementsByTagName(XS("align")); DOMElement *align; if( list->getLength() == 0 ){ DOMDocument *doc = m_element->getOwnerDocument(); align = doc->createElement(XS("align")); m_element->appendChild(align); } else{ align = (DOMElement*)list->item(0); } align->setAttribute( XS("note"), XS(note->getID().c_str()) ); if( correct ) setText( align, "correct" ); else setText( align, "wrong" ); }
bool ClsDataClientConfigWriter::saveConfig(string strFileName, list<ClsDataClientConfig> lstConfigs) { // cout << "ClsDataClientConfigWriter::saveConfig(string strFileName, list<ClsDataClientConfig> lstConfigs)" << endl; if(!bXMLPlatformInitialized){ try { XMLPlatformUtils::Initialize(); } catch(const XMLException& toCatch) { cerr << "Error during Xerces-c Initialization.\n" << " Exception message:" << toCatch.getMessage() << endl; bXMLPlatformInitialized = false; return false; } bXMLPlatformInitialized = true; } DOMImplementation *impl = DOMImplementationRegistry::getDOMImplementation(XMLString::transcode((const char*)"Range")); DOMDocumentType *dtd = impl->createDocumentType(XMLString::transcode(ConfigTagLibrary::DataManagerConfiguration()), XMLString::transcode("-//INI/iqr421"), XMLString::transcode("iqrDataManagerConfiguration.dtd")); DOMDocument *ddocConfig = impl->createDocument(0, XMLString::transcode(ConfigTagLibrary::DataManagerConfiguration()), dtd); DOMElement *delemConfig; delemConfig = ddocConfig->getDocumentElement(); list<ClsDataClientConfig>::iterator itConfigs; for(itConfigs=lstConfigs.begin(); itConfigs != lstConfigs.end(); itConfigs++){ string strID = (*itConfigs).getID(); string strType = (*itConfigs).getType(); pair<int,int> pPosition = (*itConfigs).getPosition(); pair<int,int> pGeometry = (*itConfigs).getGeometry(); DOMElement *delemDataClient; delemDataClient = ddocConfig->createElement(XMLString::transcode(ConfigTagLibrary::DataClientTag())); delemDataClient->setAttribute(XMLString::transcode(ConfigTagLibrary::TypeTag()), XMLString::transcode(strType.c_str())); delemDataClient->setAttribute(XMLString::transcode(ConfigTagLibrary::IDTag()), XMLString::transcode(strID.c_str())); delemConfig->appendChild(delemDataClient); DOMElement *delemPosition; delemPosition = ddocConfig->createElement(XMLString::transcode(ConfigTagLibrary::PositionTag())); delemPosition->setAttribute(XMLString::transcode(ConfigTagLibrary::PositionXTag()), XMLString::transcode(iqrUtils::int2string(pPosition.first).c_str())); delemPosition->setAttribute(XMLString::transcode(ConfigTagLibrary::PositionYTag()), XMLString::transcode(iqrUtils::int2string(pPosition.second).c_str())); delemDataClient->appendChild(delemPosition); DOMElement *delemGeometry; delemGeometry = ddocConfig->createElement(XMLString::transcode(ConfigTagLibrary::Geometry())); delemGeometry->setAttribute(XMLString::transcode(ConfigTagLibrary::GeometryWidthTag()), XMLString::transcode(iqrUtils::int2string(pGeometry.first).c_str())); delemGeometry->setAttribute(XMLString::transcode(ConfigTagLibrary::GeometryHeightTag()), XMLString::transcode(iqrUtils::int2string(pGeometry.second).c_str())); delemDataClient->appendChild(delemGeometry); list<pair<string, string> > lstParameters = (*itConfigs).getListParameters(); list<pair<string, string> >::iterator itLstParameters; for(itLstParameters = lstParameters.begin(); itLstParameters != lstParameters.end(); itLstParameters++){ string strParamName = (*itLstParameters).first; string strParamValue = (*itLstParameters).second; DOMElement *delemParameter; delemParameter = ddocConfig->createElement(XMLString::transcode(strParamName.c_str())); delemDataClient->appendChild(delemParameter); DOMText *dtxtParamValue = ddocConfig->createTextNode(XMLString::transcode(strParamValue.c_str())); delemParameter->appendChild(dtxtParamValue); } DOMElement *delemSVD; delemSVD = ddocConfig->createElement(XMLString::transcode(ConfigTagLibrary::StateVariableDisplayTag())); delemDataClient->appendChild(delemSVD); list<ClsStateVariableDisplayConfig>lstSVDConfigs = (*itConfigs).getListStateVariableDisplayConfig(); list<ClsStateVariableDisplayConfig>::iterator itSVD; for(itSVD = lstSVDConfigs.begin(); itSVD != lstSVDConfigs.end(); itSVD++){ DOMElement *delemStateVariable; delemStateVariable = ddocConfig->createElement(XMLString::transcode(ConfigTagLibrary::StateVariableDisplaysTag())); delemSVD->appendChild(delemStateVariable); delemStateVariable->setAttribute(XMLString::transcode(ConfigTagLibrary::IDTag()), XMLString::transcode((*itSVD).getID().c_str())); /* delemStateVariable->setAttribute(XMLString::transcode(ConfigTagLibrary::TypeTag()), XMLString::transcode((*itSVD).getItemType().c_str())); */ delemStateVariable->setAttribute(XMLString::transcode(ConfigTagLibrary::ItemIDTag()), XMLString::transcode((*itSVD).getItemID().c_str())); delemStateVariable->setAttribute(XMLString::transcode(ConfigTagLibrary::SelectedIndicesTag()), XMLString::transcode((*itSVD).getSelectedIndices().c_str())); list<pair<string, string> > lstParametersSVD = (*itSVD).getListParameters(); list<pair<string, string> >::iterator itLstParametersSVD; for(itLstParametersSVD = lstParametersSVD.begin(); itLstParametersSVD != lstParametersSVD.end(); itLstParametersSVD++){ string strParamName = (*itLstParametersSVD).first; string strParamValue = (*itLstParametersSVD).second; DOMElement *delemParameter; delemParameter = ddocConfig->createElement(XMLString::transcode(strParamName.c_str())); delemStateVariable->appendChild(delemParameter); DOMText *dtxtParamValue = ddocConfig->createTextNode(XMLString::transcode(strParamValue.c_str())); delemParameter->appendChild(dtxtParamValue); } } } #if XERCES_VERSION_MAJOR >= 3 DOMLSSerializer* theSerializer = ((DOMImplementationLS*)impl)->createLSSerializer(); if (theSerializer->getDomConfig()->canSetParameter(XMLUni::fgDOMWRTDiscardDefaultContent, true)) theSerializer->getDomConfig()->setParameter(XMLUni::fgDOMWRTDiscardDefaultContent, true); if (theSerializer->getDomConfig()->canSetParameter(XMLUni::fgDOMWRTFormatPrettyPrint, true)) theSerializer->getDomConfig()->setParameter(XMLUni::fgDOMWRTFormatPrettyPrint, true); #else DOMWriter* theSerializer = ((DOMImplementationLS*)impl)->createDOMWriter(); if (theSerializer->canSetFeature(XMLUni::fgDOMWRTDiscardDefaultContent, true)) theSerializer->setFeature(XMLUni::fgDOMWRTDiscardDefaultContent, true); if (theSerializer->canSetFeature(XMLUni::fgDOMWRTFormatPrettyPrint, true)) theSerializer->setFeature(XMLUni::fgDOMWRTFormatPrettyPrint, true); #endif XMLFormatTarget *myFormTarget = new LocalFileFormatTarget(strFileName.c_str()); #if XERCES_VERSION_MAJOR >= 3 DOMLSOutput* theOutput = ((DOMImplementationLS*)impl)->createLSOutput(); theOutput->setByteStream(myFormTarget); #endif try { #if XERCES_VERSION_MAJOR >= 3 theSerializer->write(delemConfig, theOutput); #else theSerializer->writeNode(myFormTarget, *delemConfig); #endif } catch (const XMLException& toCatch) { char* message = XMLString::transcode(toCatch.getMessage()); cerr << "Exception message is: \n" << message << "\n"; XMLString::release(&message); } catch (const DOMException& toCatch) { char* message = XMLString::transcode(toCatch.msg); cerr << "Exception message is: \n" << message << "\n"; XMLString::release(&message); } catch (...) { cerr << "Unexpected Exception \n" ; } // cout << myFormTarget->getRawBuffer() << endl; theSerializer->release(); delete myFormTarget; return true; }
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 { 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; };
/** * This method converts the entries in the map (created from the command-line arguments) * into XML which will then be fed as input into the parameter handling code (i.e. ParameterSet class). */ string parameterTask::buildParameterSetXML(const string & xmlFileNamePrefix) { string retVal; try { XMLPlatformUtils::Initialize(); } catch (const XMLException& toCatch) { ACS_LOG(LM_ERROR, "parameterTask::buildParameterSetXML", (LM_ERROR, "Error - XMLException - info: %s\n", StrX(toCatch.getMessage()).localForm())) } DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(StrX("XML 2.0").unicodeForm()); if (impl != NULL) { try { // create a new DOMDocument which we will populate with // entries from the command-line parameters, in order to // make an xml version of the parameter set for use internally string qualifiedName(PARAMETERSET_NAMESPACE_PREFIX); qualifiedName.append(":").append(PARAMETERSET_STRING); DOMDocument* doc = impl->createDocument( StrX(PSET_NAMESPACE_URI).unicodeForm(), // root element namespace URI. StrX(qualifiedName.c_str()).unicodeForm(), // root element name 0); // document type object (DTD). doc->setStandalone(true); // set our internal auto_ptr to point to the new document this->domDocument.reset(doc); string schemaHint(PSET_NAMESPACE_URI); schemaHint.append(" ").append(PARAMETERSET_SCHEMA_NAME); DOMElement* rootElem = doc->getDocumentElement(); rootElem->setAttribute(StrX("xmlns:xsi").unicodeForm(), StrX("http://www.w3.org/2001/XMLSchema-instance").unicodeForm()); rootElem->setAttribute(StrX("xsi:schemaLocation").unicodeForm(), StrX(schemaHint.c_str()).unicodeForm()); DOMElement* psetdefElem = doc->createElement(StrX(PSETDEF_STRING).unicodeForm()); rootElem->appendChild(psetdefElem); string xmlFileName = xmlFileNamePrefix + ".xml"; DOMText* psetdefValTextNode = doc->createTextNode(StrX(xmlFileName.c_str()).unicodeForm()); psetdefElem->appendChild(psetdefValTextNode); DOMElement* nameElem = doc->createElement(StrX(NAME_STRING).unicodeForm()); rootElem->appendChild(nameElem); DOMText* nameValTextNode = doc->createTextNode(StrX("command-line values").unicodeForm()); nameElem->appendChild(nameValTextNode); map<string, vector<string> >::iterator position; // for each parameter in the parameterMap for(position = parameterMap.begin(); position != parameterMap.end(); ++position) { // determine the type by looking it up in our parameter set definition, i.e. psetdef // (which we have obtained by parsing the task's psetdef xml file containing the task's metadata) // and add an element of the proper type to the XML document being constructed, with name equal to the // key portion of the current map entry, value equal to the value portion of the current map entry. ParamSetDef::paramTypesEnum paramType = paramSetDef->getParamTypeForName(position->first); switch(paramType) { case ParamSetDef::BOOL: { DOMElement *boolElem = createBoolElement(position->first, position->second, doc); rootElem->appendChild(boolElem); break; } case ParamSetDef::INT: { DOMElement *intElem = createIntElement(position->first, position->second, doc); rootElem->appendChild(intElem); break; } case ParamSetDef::INT_ARRAY: { DOMElement *intArrayElem = createIntArrayElement(position->first, position->second, doc); rootElem->appendChild(intArrayElem); break; } case ParamSetDef::DOUBLE: { DOMElement *doubleElem = createDoubleElement(position->first, position->second, doc); rootElem->appendChild(doubleElem); break; } case ParamSetDef::DOUBLE_ARRAY: { DOMElement * doubleArrayElem = createDoubleArrayElement(position->first, position->second, doc); rootElem->appendChild(doubleArrayElem); break; } case ParamSetDef::STRING: { DOMElement *stringElem = createStringElement(position->first, position->second, doc); rootElem->appendChild(stringElem); break; } case ParamSetDef::STRING_ARRAY: { DOMElement * stringArrayElem = createStringArrayElement(position->first, position->second, doc); rootElem->appendChild(stringArrayElem); break; } } } // construct the DOM writer DOMWriter *domWriter = impl->createDOMWriter(); if (domWriter->canSetFeature(XMLUni::fgDOMWRTFormatPrettyPrint, true)) { domWriter->setFeature(XMLUni::fgDOMWRTFormatPrettyPrint, true); } // construct the MemBufFormatTarget XMLFormatTarget *myFormatTarget = new MemBufFormatTarget(); // set the encoding to be ISO-8859-1 XMLCh tempStr[100]; XMLString::transcode("ISO-8859-1", tempStr, 99); domWriter->setEncoding(tempStr); // serialize the document to an internal memory buffer domWriter->writeNode(myFormatTarget, *doc); // get the string which is encoded in ISO-8859-1 from the MemBufFormatTarget char* theXMLString_Encoded = (char*) ((MemBufFormatTarget*)myFormatTarget)->getRawBuffer(); retVal = string(StrX(theXMLString_Encoded).localForm()); // release the memory delete myFormatTarget; delete domWriter; //doc->release(); } catch (const OutOfMemoryException& e) { ACS_LOG(LM_ERROR, "parameterTask::buildParameterSetXML", (LM_ERROR, "Error - OutOfMemoryException - info: %s\n", StrX(e.getMessage()).localForm())) } catch (const DOMException& e) { ACS_LOG(LM_ERROR, "parameterTask::buildParameterSetXML", (LM_ERROR, "Error - DOMException - info: %s\n", StrX(e.getMessage()).localForm())) } } else {
/*=========================================================================+ Build_Return_XML: Build the XML block that eTrust Admin expects the program exit to return. <eTExitReturn> <eTExitReturnCategory></eTExitReturnCategory> <eTExitReturnNative></eTExitReturnNative> <eTExitContinue></eTExitContinue> <eTExitLogMsg></eTExitLogMsg> <eTExitCustom></eTExitCustom> </eTExitReturn> The return XML buffer provided by eTrust Admin is over 4000 bytes long. There will be no problem fitting the entire output XML document into this buffer unless sLogMessage or the custom_msg built from the return values array is very long. Thus, this code attempts first to build an XML buffer with all of the provided information and if it is too long does the following: case 1: custom_msg is provided --> generate a failure exit return block with no custom_msg case 2: sLogMessage is provided, but no custom_msg --> replace the very long sLogMessage with a short one. +=========================================================================*/ void ExitXMLBlock::Build_Return_XML( STATUS_T tStatus, bool bContinueEtaExecution, string sLogMessage, string & sReturnXML, // OUT int iMaxReturnLength, bool bObscureValue // = false ) { int iRc; string suValue; UTF8 pszuValue[32]; XMLCh* pxcValue; pxcValue = UTF8toUTF16(UTFEXIT_EXITRETURN); DOMDocument* pDocument = ExitXMLBlock::g_pImplementation->createDocument(0, pxcValue, 0); delete pxcValue; DOMElement* pRootElement = pDocument->getDocumentElement(); // ...eTrust Admin Category. suValue = Convert_Status_To_Category_String(tStatus); iRc = Add_Element(pDocument, pRootElement, UTFEXIT_EXITRETURNCATEGORY, suValue); // ...Program exit return code. sprintf(pszuValue, "%d", tStatus); iRc = Add_Element(pDocument, pRootElement, UTFEXIT_EXITRETURNNATIVE, pszuValue); // ...Should eTrust Admin continue execution? suValue = (bContinueEtaExecution ? UTFEXIT_TRUE : UTFEXIT_FALSE); iRc = Add_Element(pDocument, pRootElement, UTFEXIT_EXITCONTINUE, suValue); // ...Log message. if (!sLogMessage.empty()) { iRc = Add_Element(pDocument, pRootElement, UTFEXIT_EXITLOGMSG, sLogMessage); } // ...Custom message (used for return values today; and perhaps for // other exit-type specific purposes in the future). if (m_vsReturnValues.size() > 0) { pxcValue = UTF8toUTF16(UTFEXIT_EXITCUSTOM); DOMElement* pElement = pDocument->createElement(pxcValue); delete pxcValue; pRootElement->appendChild(pElement); // Add each return value as <eTFuncReturn>...</eTFuncReturn> for (unsigned int iIndex = 0; iIndex < m_vsReturnValues.size(); iIndex++) { if (bObscureValue) { // add the obscured attribute for passwords Add_Element( pDocument, pElement, UTFEXIT_CF_FUNCRETURN, m_vsReturnValues[iIndex], "obscured", "yes"); } else { Add_Element( pDocument, pElement, UTFEXIT_CF_FUNCRETURN, m_vsReturnValues[iIndex]); } } } // Generate the return XML string DOMBuilder* pBuilder; // Parser DOMWriter* pWriter; // Serializer pWriter = ExitXMLBlock::g_pImplementation->createDOMWriter(); pBuilder = ExitXMLBlock::g_pImplementation->createDOMBuilder(DOMImplementationLS::MODE_SYNCHRONOUS, 0); pWriter->setFeature(XMLUni::fgDOMXMLDeclaration, false); pBuilder->resetDocumentPool(); const XMLCh* pxcReturnXML = pWriter->writeToString(*pRootElement); sReturnXML = UTF16toUTF8(pxcReturnXML); if (pBuilder) { delete pBuilder; } if (pWriter) { delete pWriter; } if (pDocument) { delete pDocument; pDocument = NULL; } // Check to make sure it isn't too long for the return buffer int iLength = sReturnXML.length(); if (iLength >= iMaxReturnLength) { sReturnXML = ""; sLogMessage = "ERROR: Return XML buffer too long"; // If too long, and a custom message was provided, fail the // call (and consequently do not report an output value). if (m_vsReturnValues.size() > 0) { m_vsReturnValues.clear(); tStatus = E_FAILURE; bContinueEtaExecution = false; } } }
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; }
void writeHtmlFile(Tag2Html::MP3Collection* mp3Collection) { XMLPlatformUtils::Initialize(); DOMImplementation* domImplementation = DOMImplementationRegistry::getDOMImplementation(XMLString::transcode("core")); // <html> DOMDocument* doc = domImplementation->createDocument(0, XMLString::transcode("html"), 0); DOMDocumentType* docType = domImplementation->createDocumentType(XMLString::transcode("html"), XMLString::transcode(""), XMLString::transcode("")); doc->insertBefore(docType, doc->getDocumentElement()); // <head> DOMElement* head = doc->createElement(XMLString::transcode("head")); // <link rel="stylesheet" type="text/css" href="./index.css"> DOMElement* linkStylesheet = doc->createElement(XMLString::transcode("link")); linkStylesheet->setAttribute(XMLString::transcode("rel"), XMLString::transcode("stylesheet")); linkStylesheet->setAttribute(XMLString::transcode("type"), XMLString::transcode("text/css")); linkStylesheet->setAttribute(XMLString::transcode("href"), XMLString::transcode("index.css")); head->appendChild(linkStylesheet); // <title>MP3-Leser</title> DOMElement* title = doc->createElement(XMLString::transcode("title")); title->setTextContent(XMLString::transcode("MP3-Leser")); head->appendChild(title); // <meta http-equiv="Content-Type" content="text/html" charset="utf-8"> DOMElement* meta = doc->createElement(XMLString::transcode("meta")); meta->setAttribute(XMLString::transcode("http-equiv"), XMLString::transcode("Content-Type")); meta->setAttribute(XMLString::transcode("content"), XMLString::transcode("text/html")); meta->setAttribute(XMLString::transcode("charset"), XMLString::transcode("utf-8")); head->appendChild(meta); // <body> DOMElement* body = doc->createElement(XMLString::transcode("body")); // <h1> DOMElement* h1 = doc->createElement(XMLString::transcode("h1")); // Track List ( view <a href="stats.html">stats</a>, <a href="info.html">info</a> ) h1->appendChild(doc->createTextNode(XMLString::transcode("Track List ( view "))); DOMElement* statsLink = doc->createElement(XMLString::transcode("a")); statsLink->setAttribute(XMLString::transcode("href"), XMLString::transcode("stats.html")); statsLink->setTextContent(XMLString::transcode("stats")); h1->appendChild(statsLink); h1->appendChild(doc->createTextNode(XMLString::transcode(", "))); DOMElement* infoLink = doc->createElement(XMLString::transcode("a")); infoLink->setAttribute(XMLString::transcode("href"), XMLString::transcode("info.html")); infoLink->setTextContent(XMLString::transcode("info")); h1->appendChild(infoLink); h1->appendChild(doc->createTextNode(XMLString::transcode(" )"))); body->appendChild(h1); // <table align="center" width="1000"> DOMElement* table = doc->createElement(XMLString::transcode("table")); table->setAttribute(XMLString::transcode("align"), XMLString::transcode("center")); // <thead> DOMElement* tHead = doc->createElement(XMLString::transcode("thead")); // <tr bgcolor="#CCCCCC"> DOMElement* tHeadRow = doc->createElement(XMLString::transcode("tr")); tHeadRow->setAttribute(XMLString::transcode("bgcolor"), XMLString::transcode("#CCCCCC")); // <th>Track</th> DOMElement* tHeadColumnTrack = doc->createElement(XMLString::transcode("th")); tHeadColumnTrack->setTextContent(XMLString::transcode("Track")); tHeadRow->appendChild(tHeadColumnTrack); // <th>Artist</th> DOMElement* tHeadColumnArtist = doc->createElement(XMLString::transcode("th")); tHeadColumnArtist->setTextContent(XMLString::transcode("Artist")); tHeadRow->appendChild(tHeadColumnArtist); // <th>Title</th> DOMElement* tHeadColumnTitle = doc->createElement(XMLString::transcode("th")); tHeadColumnTitle->setTextContent(XMLString::transcode("Title")); tHeadRow->appendChild(tHeadColumnTitle); // <th>Album</th> DOMElement* tHeadColumnAlbum = doc->createElement(XMLString::transcode("th")); tHeadColumnAlbum->setTextContent(XMLString::transcode("Album")); tHeadRow->appendChild(tHeadColumnAlbum); // <th>Year</th> DOMElement* tHeadColumnYear = doc->createElement(XMLString::transcode("th")); tHeadColumnYear->setTextContent(XMLString::transcode("Year")); tHeadRow->appendChild(tHeadColumnYear); // <th>Genre</th> DOMElement* tHeadColumnGenre = doc->createElement(XMLString::transcode("th")); tHeadColumnGenre->setTextContent(XMLString::transcode("Genre")); tHeadRow->appendChild(tHeadColumnGenre); // <th>Comment</th> DOMElement* tHeadColumnComment = doc->createElement(XMLString::transcode("th")); tHeadColumnComment->setTextContent(XMLString::transcode("Comment")); tHeadRow->appendChild(tHeadColumnComment); // <th>Length</th> DOMElement* tHeadColumnLength = doc->createElement(XMLString::transcode("th")); tHeadColumnLength->setTextContent(XMLString::transcode("Length")); tHeadRow->appendChild(tHeadColumnLength); // <th>Filename</th> DOMElement* tHeadColumnFilename = doc->createElement(XMLString::transcode("th")); tHeadColumnFilename->setTextContent(XMLString::transcode("Filename")); tHeadRow->appendChild(tHeadColumnFilename); tHead->appendChild(tHeadRow); table->appendChild(tHead); // <tbody> DOMElement* tBody = doc->createElement(XMLString::transcode("tbody")); ostringstream convert; list<Tag2Html::MP3Infos*> sortedList = mp3Collection->getSortedList(); for (list<Tag2Html::MP3Infos*>::iterator mp3info = sortedList.begin(); mp3info != sortedList.end(); mp3info++) { DOMElement* row = doc->createElement(XMLString::transcode("tr")); convert.str(""); convert << (*mp3info)->track; DOMElement* trackColumn = doc->createElement(XMLString::transcode("td")); trackColumn->setTextContent(XMLString::transcode(convert.str().c_str())); row->appendChild(trackColumn); DOMElement* artistColumn = doc->createElement(XMLString::transcode("td")); artistColumn->setTextContent(XMLString::transcode((*mp3info)->artist.c_str())); row->appendChild(artistColumn); DOMElement* titleColumn = doc->createElement(XMLString::transcode("td")); titleColumn->setTextContent(XMLString::transcode((*mp3info)->title.c_str())); row->appendChild(titleColumn); DOMElement* albumColumn = doc->createElement(XMLString::transcode("td")); albumColumn->setTextContent(XMLString::transcode((*mp3info)->album.c_str())); row->appendChild(albumColumn); convert.str(""); convert << (*mp3info)->year; DOMElement* yearColumn = doc->createElement(XMLString::transcode("td")); yearColumn->setTextContent(XMLString::transcode(convert.str().c_str())); row->appendChild(yearColumn); DOMElement* genreColumn = doc->createElement(XMLString::transcode("td")); genreColumn->setTextContent(XMLString::transcode((*mp3info)->genre.c_str())); row->appendChild(genreColumn); DOMElement* commentColumn = doc->createElement(XMLString::transcode("td")); commentColumn->setTextContent(XMLString::transcode((*mp3info)->comment.c_str())); row->appendChild(commentColumn); DOMElement* lengthColumn = doc->createElement(XMLString::transcode("td")); if ((*mp3info)->length < 3600) { char trackLength[12]; struct tm* timeinfo = new tm(); int seconds = (*mp3info)->length; if (seconds >= 60) { int minutes = seconds / 60; if (minutes >= 60) { timeinfo->tm_hour = minutes / 60; timeinfo->tm_min = minutes / 60; } else { timeinfo->tm_min = seconds / 60; } } timeinfo->tm_sec = seconds % 60; strftime(trackLength, 12, "%H:%M:%S", timeinfo); lengthColumn->setTextContent(XMLString::transcode(trackLength)); } row->appendChild(lengthColumn); DOMElement* filenameColumn = doc->createElement(XMLString::transcode("td")); filenameColumn->setTextContent(XMLString::transcode((*mp3info)->filename.c_str())); row->appendChild(filenameColumn); tBody->appendChild(row); } table->appendChild(tBody); body->appendChild(table); doc->getDocumentElement()->appendChild(head); doc->getDocumentElement()->appendChild(body); DOMWriter* writer = ((DOMImplementationLS*)domImplementation)->createDOMWriter(); if (writer->canSetFeature(XMLUni::fgDOMWRTFormatPrettyPrint, true)) { writer->setFeature(XMLUni::fgDOMWRTFormatPrettyPrint, true); } if (writer->canSetFeature(XMLUni::fgDOMXMLDeclaration, false)) { writer->setFeature(XMLUni::fgDOMXMLDeclaration, false); } XMLFormatTarget *fileFormatTarget = new LocalFileFormatTarget("index.html"); writer->writeNode(fileFormatTarget, *doc); fileFormatTarget->flush(); writer->release(); doc->release(); XMLPlatformUtils::Terminate(); writeCssFile(); writeStatFile(mp3Collection); writeInfoFile(mp3Collection); }
int main(int argC, char*[]) { // 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; } { // Nest entire test in an inner block. // The tree we create below is the same that the XercesDOMParser would // have created, except that no whitespace text nodes would be created. // <company> // <product>Xerces-C</product> // <category idea='great'>XML Parsing Tools</category> // <developedBy>Apache Software Foundation</developedBy> // </company> DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(X("Core")); if (impl != NULL) { try { DOMDocument* doc = impl->createDocument( 0, // root element namespace URI. X("company"), // root element name 0); // document type object (DTD). DOMElement* rootElem = doc->getDocumentElement(); DOMElement* prodElem = doc->createElement(X("product")); rootElem->appendChild(prodElem); DOMText* prodDataVal = doc->createTextNode(X("Xerces-C")); prodElem->appendChild(prodDataVal); DOMElement* catElem = doc->createElement(X("category")); rootElem->appendChild(catElem); catElem->setAttribute(X("idea"), X("great")); DOMText* catDataVal = doc->createTextNode(X("XML Parsing Tools")); catElem->appendChild(catDataVal); DOMElement* devByElem = doc->createElement(X("developedBy")); rootElem->appendChild(devByElem); DOMText* devByDataVal = doc->createTextNode(X("Apache Software Foundation")); devByElem->appendChild(devByDataVal); // // 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; 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; } } // (inpl != NULL) else { XERCES_STD_QUALIFIER cerr << "Requested implementation is not supported" << XERCES_STD_QUALIFIER endl; errorCode = 4; } } XMLPlatformUtils::Terminate(); return errorCode; }
void writeInfoFile(Tag2Html::MP3Collection* mp3Collection) { ostringstream convert; XMLPlatformUtils::Initialize(); DOMImplementation* domImplementation = DOMImplementationRegistry::getDOMImplementation(XMLString::transcode("core")); // <html> DOMDocument* doc = domImplementation->createDocument(0, XMLString::transcode("html"), 0); DOMDocumentType* docType = domImplementation->createDocumentType(XMLString::transcode("html"), XMLString::transcode(""), XMLString::transcode("")); doc->insertBefore(docType, doc->getDocumentElement()); // <head> DOMElement* head = doc->createElement(XMLString::transcode("head")); // <link rel="stylesheet" type="text/css" href="./index.css"> DOMElement* headLink = doc->createElement(XMLString::transcode("link")); headLink->setAttribute(XMLString::transcode("rel"), XMLString::transcode("stylesheet")); headLink->setAttribute(XMLString::transcode("type"), XMLString::transcode("text/css")); headLink->setAttribute(XMLString::transcode("href"), XMLString::transcode("index.css")); head->appendChild(headLink); // <title>tag2html info page</title> DOMElement* headTitle = doc->createElement(XMLString::transcode("title")); headTitle->setTextContent(XMLString::transcode("tag2html info page")); head->appendChild(headTitle); // <meta http-equiv="Content-Type" content="text/html" charset="utf-8"> DOMElement* headMeta = doc->createElement(XMLString::transcode("meta")); headMeta->setAttribute(XMLString::transcode("http-equiv"), XMLString::transcode("Content-Type")); headMeta->setAttribute(XMLString::transcode("content"), XMLString::transcode("text/html")); headMeta->setAttribute(XMLString::transcode("charset"), XMLString::transcode("utf-8")); head->appendChild(headMeta); // <body> DOMElement* body = doc->createElement(XMLString::transcode("body")); // <h1>File Info</h1> DOMElement* h1 = doc->createElement(XMLString::transcode("h1")); h1->setTextContent(XMLString::transcode("File Info")); body->appendChild(h1); // <table align="center"> DOMElement* table = doc->createElement(XMLString::transcode("table")); table->setAttribute(XMLString::transcode("align"), XMLString::transcode("center")); // <thead> DOMElement* tHead = doc->createElement(XMLString::transcode("thead")); // <tr bgcolor="#CCCCCC"> DOMElement* tHeadRow = doc->createElement(XMLString::transcode("tr")); tHeadRow->setAttribute(XMLString::transcode("bgcolor"), XMLString::transcode("#CCCCCC")); // <th style="width: 100px; font-weight: bold;">Filename</th> DOMElement* tHeadColumn1 = doc->createElement(XMLString::transcode("th")); tHeadColumn1->setTextContent(XMLString::transcode("Filename")); tHeadRow->appendChild(tHeadColumn1); // <th style="width: 50px; font-weight: bold;">Bitrate</th> DOMElement* tHeadColumn2 = doc->createElement(XMLString::transcode("th")); tHeadColumn2->setTextContent(XMLString::transcode("Bitrate")); tHeadRow->appendChild(tHeadColumn2); // <th style="width: 100px; font-weight: bold;">MPEG Audio Version</th> DOMElement* tHeadColumn3 = doc->createElement(XMLString::transcode("th")); tHeadColumn3->setTextContent(XMLString::transcode("MPEG Audio Version")); tHeadRow->appendChild(tHeadColumn3); // <th style="width: 100px; font-weight: bold;">Layer</th> DOMElement* tHeadColumn4 = doc->createElement(XMLString::transcode("th")); tHeadColumn4->setTextContent(XMLString::transcode("Layer")); tHeadRow->appendChild(tHeadColumn4); // <th style="width: 100px; font-weight: bold;">Error Protection</th> DOMElement* tHeadColumn5 = doc->createElement(XMLString::transcode("th")); tHeadColumn5->setTextContent(XMLString::transcode("Error Protection")); tHeadRow->appendChild(tHeadColumn5); // <th style="width: 100px; font-weight: bold;">Sampling Rate</th> DOMElement* tHeadColumn6 = doc->createElement(XMLString::transcode("th")); tHeadColumn6->setTextContent(XMLString::transcode("Sampling Rate")); tHeadRow->appendChild(tHeadColumn6); // <th style="width: 50px; font-weight: bold;">Private</th> DOMElement* tHeadColumn7 = doc->createElement(XMLString::transcode("th")); tHeadColumn7->setTextContent(XMLString::transcode("Private")); tHeadRow->appendChild(tHeadColumn7); // <th style="width: 100px; font-weight: bold;">Channel Mode</th> DOMElement* tHeadColumn8 = doc->createElement(XMLString::transcode("th")); tHeadColumn8->setTextContent(XMLString::transcode("Channel Mode")); tHeadRow->appendChild(tHeadColumn8); // <th style="width: 100px; font-weight: bold;">Copyright</th> DOMElement* tHeadColumn9 = doc->createElement(XMLString::transcode("th")); tHeadColumn9->setTextContent(XMLString::transcode("Copyright")); tHeadRow->appendChild(tHeadColumn9); // <th style="width: 50px; font-weight: bold;">Original</th> DOMElement* tHeadColumn10 = doc->createElement(XMLString::transcode("th")); tHeadColumn10->setTextContent(XMLString::transcode("Original")); tHeadRow->appendChild(tHeadColumn10); // <th style="width: 100px; font-weight: bold;">Emphasis</th> DOMElement* tHeadColumn11 = doc->createElement(XMLString::transcode("th")); tHeadColumn11->setTextContent(XMLString::transcode("Emphasis")); tHeadRow->appendChild(tHeadColumn11); tHead->appendChild(tHeadRow); table->appendChild(tHead); // <tbody> DOMElement* tBody = doc->createElement(XMLString::transcode("tbody")); list<Tag2Html::MP3Infos*> sortedList = mp3Collection->getSortedList(); for (list<Tag2Html::MP3Infos*>::iterator mp3info = sortedList.begin(); mp3info != sortedList.end(); mp3info++) { // <tr> DOMElement* currentRow = doc->createElement(XMLString::transcode("tr")); // <td>" << mytag->filename << "</td> DOMElement* columnFilename = doc->createElement(XMLString::transcode("td")); columnFilename->setTextContent(XMLString::transcode((*mp3info)->filename.c_str())); currentRow->appendChild(columnFilename); // <td>" << myheader->Bitrate << "</td> DOMElement* columnBitrate = doc->createElement(XMLString::transcode("td")); convert.str(""); convert << (*mp3info)->bitrate << " kbit/s"; columnBitrate->setTextContent(XMLString::transcode(convert.str().c_str())); currentRow->appendChild(columnBitrate); // <td>" << myheader->MPEG_Audio_Version << "</td> DOMElement* columnMPEGAudioVersion = doc->createElement(XMLString::transcode("td")); switch((*mp3info)->version) { case TagLib::MPEG::Header::Version::Version1: columnMPEGAudioVersion->setTextContent(XMLString::transcode("1")); break; case TagLib::MPEG::Header::Version::Version2: columnMPEGAudioVersion->setTextContent(XMLString::transcode("2")); break; case TagLib::MPEG::Header::Version::Version2_5: columnMPEGAudioVersion->setTextContent(XMLString::transcode("2.5")); break; } currentRow->appendChild(columnMPEGAudioVersion); // <td>" << myheader->Layer << "</td> DOMElement* columnLayer = doc->createElement(XMLString::transcode("td")); convert.str(""); convert << (*mp3info)->layer; columnLayer->setTextContent(XMLString::transcode(convert.str().c_str())); currentRow->appendChild(columnLayer); // <td>" << myheader->Error_Protection << "</td> DOMElement* columnErrorProtection = doc->createElement(XMLString::transcode("td")); if ((*mp3info)->protectionEnabled) { columnErrorProtection->setTextContent(XMLString::transcode("yes")); } else { columnErrorProtection->setTextContent(XMLString::transcode("no")); } currentRow->appendChild(columnErrorProtection); // <td>" << myheader->Samplerate << "</td> DOMElement* columnSamplerate = doc->createElement(XMLString::transcode("td")); convert.str(""); convert << (*mp3info)->samplerate << " Hz"; columnSamplerate->setTextContent(XMLString::transcode(convert.str().c_str())); currentRow->appendChild(columnSamplerate); // <td>" << myheader->Private << "</td> DOMElement* columnPrivate = doc->createElement(XMLString::transcode("td")); columnPrivate->setTextContent(XMLString::transcode("")); currentRow->appendChild(columnPrivate); // <td>" << myheader->Channel_Mode << "</td> DOMElement* columnChannelMode = doc->createElement(XMLString::transcode("td")); switch((*mp3info)->channelMode) { case TagLib::MPEG::Header::ChannelMode::DualChannel: columnChannelMode->setTextContent(XMLString::transcode("Dual Channel")); break; case TagLib::MPEG::Header::ChannelMode::JointStereo: columnChannelMode->setTextContent(XMLString::transcode("Joint Stereo")); break; case TagLib::MPEG::Header::ChannelMode::SingleChannel: columnChannelMode->setTextContent(XMLString::transcode("Single Channel")); break; case TagLib::MPEG::Header::ChannelMode::Stereo: columnChannelMode->setTextContent(XMLString::transcode("Stereo")); break; } currentRow->appendChild(columnChannelMode); // <td>" << myheader->Copyright << "</td> DOMElement* columnCopyright = doc->createElement(XMLString::transcode("td")); if ((*mp3info)->isCopyrighted) { columnCopyright->setTextContent(XMLString::transcode("yes")); } else { columnCopyright->setTextContent(XMLString::transcode("no")); } currentRow->appendChild(columnCopyright); // <td>" << myheader->Original << "</td> DOMElement* columnOriginal = doc->createElement(XMLString::transcode("td")); if ((*mp3info)->isOriginal) { columnOriginal->setTextContent(XMLString::transcode("yes")); } else { columnOriginal->setTextContent(XMLString::transcode("no")); } currentRow->appendChild(columnOriginal); // <td>" << myheader->Emphasis << "</td> DOMElement* columnEmphasis = doc->createElement(XMLString::transcode("td")); columnEmphasis->setTextContent(XMLString::transcode("")); currentRow->appendChild(columnEmphasis); tBody->appendChild(currentRow); } table->appendChild(tBody); body->appendChild(table); doc->getDocumentElement()->appendChild(head); doc->getDocumentElement()->appendChild(body); DOMWriter* writer = ((DOMImplementationLS*)domImplementation)->createDOMWriter(); if (writer->canSetFeature(XMLUni::fgDOMWRTFormatPrettyPrint, true)) { writer->setFeature(XMLUni::fgDOMWRTFormatPrettyPrint, true); } if (writer->canSetFeature(XMLUni::fgDOMXMLDeclaration, false)) { writer->setFeature(XMLUni::fgDOMXMLDeclaration, false); } XMLFormatTarget *fileFormatTarget = new LocalFileFormatTarget("info.html"); writer->writeNode(fileFormatTarget, *doc); fileFormatTarget->flush(); writer->release(); doc->release(); XMLPlatformUtils::Terminate(); }
bool ComponentInstallationImpl::addInstalledComponent (ComponentImplementation* aComponentImplementation) { // // parse the descriptor file // DOMXMLParser* parser = new DOMXMLParser(); if (parser->parse(strdup(inst_file_.c_str())) != 0) { std::cerr << "Error during parsing " << inst_file_ << std::endl; return false; } // // add the new implementation // DOMDocument* doc = parser->getDocument(); DOMElement* root = doc->getDocumentElement(); root->appendChild(doc->createTextNode(X("\n "))); DOMElement* servants = doc->createElement(X("servants")); servants->appendChild(doc->createTextNode(X("\n "))); servants->setAttribute(X("code"), X(aComponentImplementation->servant_module_.c_str())); servants->setAttribute(X("entry"), X(aComponentImplementation->servant_entry_point_.c_str())); DOMElement* business = doc->createElement(X("business")); business->appendChild(doc->createTextNode(X("\n "))); business->setAttribute(X("code"), X(aComponentImplementation->executor_module_.c_str())); business->setAttribute(X("entry"), X(aComponentImplementation->executor_entry_point_.c_str())); DOMElement* impl = doc->createElement(X("implementation")); impl->setAttribute(X("id"), X(aComponentImplementation->uuid_.c_str())); impl->appendChild (doc->createTextNode(X("\n "))); impl->appendChild (servants); impl->appendChild (doc->createTextNode(X("\n "))); impl->appendChild (business); impl->appendChild (doc->createTextNode(X("\n "))); root->appendChild (impl); root->appendChild (doc->createTextNode(X("\n"))); // // write the new list // try { // // get a serializer, an instance of DOMWriter // XMLCh tempStr[100]; XMLString::transcode("LS", tempStr, 99); DOMImplementation *impl = DOMImplementationRegistry::getDOMImplementation(tempStr); DOMWriter *theSerializer = ((DOMImplementationLS*)impl)->createDOMWriter(); if (theSerializer->canSetFeature(XMLUni::fgDOMWRTFormatPrettyPrint, true)) { theSerializer->setFeature(XMLUni::fgDOMWRTFormatPrettyPrint, true); } XMLFormatTarget *myFormTarget = new LocalFileFormatTarget(inst_file_.c_str()); // // do the serialization through DOMWriter::writeNode(); // theSerializer->writeNode(myFormTarget, *doc); delete theSerializer; delete myFormTarget; } catch (XMLException& e) { std::cerr << "An error occurred during creation of output transcoder. Msg is:" << std::endl; std::cerr << StrX(e.getMessage()) << std::endl; } // delete parser delete parser; return true; }
bool XCube::writeXML(const std::string &outputfile) { DWXML xml; xercesc::XercesDOMParser *m_DOMXmlParser1=xml.getDOMParser(); m_DOMXmlParser1->setValidationScheme( XercesDOMParser::Val_Auto ); m_DOMXmlParser1->setDoNamespaces( false ); m_DOMXmlParser1->setDoSchema( false ); m_DOMXmlParser1->setLoadExternalDTD( false ); XMLCh temp2[100]; XMLString::transcode("Core", temp2, 99); DOMImplementation* impl2 = DOMImplementationRegistry::getDOMImplementation(temp2); DOMDocument* doc = impl2->createDocument( 0, // root element namespace URI. XMLString::transcode("Schema"), // root element name 0); // document type object (DTD). if (impl2 != NULL) { try { DOMElement *cubeElem = doc->createElement(XMLString::transcode("Cube")); if(this->_name != "") cubeElem->setAttribute(XMLString::transcode("name"),XMLString::transcode(this->_name.c_str())); if(this->_fact != "") cubeElem->setAttribute(XMLString::transcode("tablename"),XMLString::transcode(this->_fact.c_str())); if(this->_dimensions.size() > 0) { for(int i = 0; i < this->_dimensions.size(); i ++) { Dimension *tempDimension = this->getDimension(this->_dimensions[i]->getName()); cubeElem->appendChild(tempDimension->recursiveXML(doc)); } } XSchema *tempschema = this->getSchema(); DOMElement* schemaElem = doc->getDocumentElement();//create root if(DataSource *tempDS = tempschema->getDataSource()) { schemaElem -> appendChild(tempDS->recursiveXML(doc)); } schemaElem -> appendChild(cubeElem); } catch (const OutOfMemoryException &) { XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl; return false; } catch (const DOMException& e) { XERCES_STD_QUALIFIER cerr << "DOMException code is: " << e.code << XERCES_STD_QUALIFIER endl; return false; } catch (...) { XERCES_STD_QUALIFIER cerr << "An error occurred creating the document" << XERCES_STD_QUALIFIER endl; return false; } } else {return false;} //use DOMwriter for export XML file //Writer Ini bool bRet = true; XMLCh tempStr[100]; XMLString::transcode("LS", tempStr, 99); DOMImplementation *impl = DOMImplementationRegistry::getDOMImplementation(tempStr); DOMWriter *m_pWriter = ((DOMImplementationLS*)impl)->createDOMWriter(); //set XML File in "UTF-8" XMLCh *encoding = XMLString::transcode("UTF-8"); m_pWriter -> setEncoding(encoding); // DOMDocument* m_pDoc; const char * outfile = outputfile.c_str(); XMLFormatTarget* m_pFormatTarget = new LocalFileFormatTarget(outfile); // construct the LocalFileFormatTarget // m_pFormatTarget = new LocalFileFormatTarget(szPath); // serialize a DOMNode to the local file "myXMLFile.xml" //Write File in UTF-8 bRet = m_pWriter->writeNode(m_pFormatTarget, *doc); if (bRet == false) { return false; } else { try { // optionally, you can flush the buffer to ensure all contents are written m_pFormatTarget->flush(); delete m_pFormatTarget; delete m_DOMXmlParser1; delete m_pWriter; doc->release(); XMLPlatformUtils::Terminate(); return true; } catch (const OutOfMemoryException&) { XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl; return false; } catch (XMLException& e) { XERCES_STD_QUALIFIER cerr << "An error occurred during creation of output transcoder. Msg is:" << XERCES_STD_QUALIFIER endl << XMLString::transcode(e.getMessage()) << XERCES_STD_QUALIFIER endl; return false; } } }
/** * 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; } }
DOMDocument* Metadata::toXML(void){ // 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 NULL; } { DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(X("Core")); if (impl != NULL) { try { DOMDocument* doc = impl->createDocument( // FIXME: change namespace URI? X("http://oodt.jpl.nasa.gov/1.0/cas"), // root element namespace URI. X("cas:metadata"), // root element name NULL/*pDoctype*/); // document type object (DTD). DOMElement* rootElem = doc->getDocumentElement(); for(map<string, vector<string> >::iterator i = elementMap.begin(); i != elementMap.end(); i++){ DOMElement* metaElem = doc->createElement(X("keyval")); rootElem->appendChild(metaElem); DOMElement* keyElem = doc->createElement(X("key")); metaElem->appendChild(keyElem); DOMText* keyTextElem = doc->createTextNode(X(i->first)); keyElem->appendChild(keyTextElem); if(i->second.size() > 1){ metaElem->setAttribute(X("type"), X("vector")); } else{ metaElem->setAttribute(X("type"), X("scalar")); } for(int j=0; j < i->second.size(); j++){ DOMElement* valueElem = doc->createElement(X("val")); DOMText* valTextElem = doc->createTextNode(X(i->second[j])); valueElem->appendChild(valTextElem); metaElem->appendChild(valueElem); } } return doc; } catch (const OutOfMemoryException&) { XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl; } catch (const DOMException& e) { XERCES_STD_QUALIFIER cerr << "DOMException code is: " << e.code << XERCES_STD_QUALIFIER endl; } catch (...) { XERCES_STD_QUALIFIER cerr << "An error occurred creating the document" << XERCES_STD_QUALIFIER endl; } } else { XERCES_STD_QUALIFIER cerr << "Requested implementation is not supported" << XERCES_STD_QUALIFIER endl; } } XMLPlatformUtils::Terminate(); return NULL; }
void EntityXMLFileWriter::appentEntityComponents(xercesc::DOMElement* parentElement, const World* world, EntityID entity) { using namespace xercesc; DOMDocument* doc = parentElement->getOwnerDocument(); auto& componentPools = world->GetComponentPools(); // Step through all component pools to get an entity's components // HACK: This is sloooow. for (auto& kv : componentPools) { const std::string& componentName = kv.first; if (!world->HasComponent(entity, componentName)) { continue; } std::string qualifiedComponentName = "c:" + componentName; DOMElement* componentElement = doc->createElement(X(qualifiedComponentName)); parentElement->appendChild(componentElement); ComponentWrapper c = kv.second->GetByEntity(entity); for (auto& kv : c.Info.Fields) { std::string fieldName = kv.first; auto& field = kv.second; // Ignore fields that are equal to the default // HACK: This is probably sloooooow, but it's okay. if (memcmp(c.Data + field.Offset, c.Info.Defaults.get() + field.Offset, field.Stride) == 0) { continue; } DOMElement* fieldElement = doc->createElement(X(fieldName)); componentElement->appendChild(fieldElement); if (field.Type == "Vector") { const glm::vec3& vec = c[fieldName]; fieldElement->setAttribute(X("X"), X(boost::lexical_cast<std::string>(vec.x))); fieldElement->setAttribute(X("Y"), X(boost::lexical_cast<std::string>(vec.y))); fieldElement->setAttribute(X("Z"), X(boost::lexical_cast<std::string>(vec.z))); } else if (field.Type == "Color") { const glm::vec4& vec = c[fieldName]; fieldElement->setAttribute(X("R"), X(boost::lexical_cast<std::string>(vec.r))); fieldElement->setAttribute(X("G"), X(boost::lexical_cast<std::string>(vec.g))); fieldElement->setAttribute(X("B"), X(boost::lexical_cast<std::string>(vec.b))); fieldElement->setAttribute(X("A"), X(boost::lexical_cast<std::string>(vec.a))); } else if (field.Type == "Quaternion") { const glm::quat& q = c[fieldName]; fieldElement->setAttribute(X("X"), X(boost::lexical_cast<std::string>(q.x))); fieldElement->setAttribute(X("Y"), X(boost::lexical_cast<std::string>(q.y))); fieldElement->setAttribute(X("Z"), X(boost::lexical_cast<std::string>(q.z))); fieldElement->setAttribute(X("W"), X(boost::lexical_cast<std::string>(q.w))); } else if (field.Type == "int") { const int& value = c[fieldName]; fieldElement->appendChild(doc->createTextNode(X(boost::lexical_cast<std::string>(value)))); } else if (field.Type == "enum") { const ComponentInfo::EnumType& value = c[fieldName]; auto& enumDef = c.Info.Meta->FieldEnumDefinitions.at(fieldName); for (auto& kv : enumDef) { if (kv.second == value) { fieldElement->appendChild(doc->createElement(X(kv.first))); break; } } } else if (field.Type == "float") { const float& value = c[fieldName]; fieldElement->appendChild(doc->createTextNode(X(boost::lexical_cast<std::string>(value)))); } else if (field.Type == "double") { const double& value = c[fieldName]; fieldElement->appendChild(doc->createTextNode(X(boost::lexical_cast<std::string>(value)))); } else if (field.Type == "bool") { const bool& value = c[fieldName]; if (value) { fieldElement->appendChild(doc->createTextNode(X("true"))); } else { fieldElement->appendChild(doc->createTextNode(X("false"))); } } else if (field.Type == "string") { const std::string& value = c[fieldName]; fieldElement->appendChild(doc->createTextNode(X(value))); } } } }
int main(int argC, char*argV[]) { // Initialize the XML4C2 system. try { XMLPlatformUtils::Initialize();/*init*/ } 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; } DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(X("LS"));/**Implementation*/ DOMLSSerializer* theSerializer = ((DOMImplementationLS*)impl)->createLSSerializer();/** createLSSerializer*/ DOMLSOutput *theOutputDesc = ((DOMImplementationLS*)impl)->createLSOutput();/**createLSOutput*/ MemBufFormatTarget* target = new MemBufFormatTarget(); theOutputDesc->setByteStream(target); if (impl != NULL) { try { DOMDocument* doc = impl->createDocument( 0, // root element namespace URI. /**可用资源标识*/ X("corporation"), // root element name /**a large companny*/ 0); // document type object (DTD). /**mem mannager mode object*/ doc->setXmlStandalone(true); DOMElement* rootElem = doc->getDocumentElement(); rootElem->setAttribute(X("xmlns"), X("com:cmcc:corporation")); rootElem->setAttribute(X("xmlns:xsi"), X("http://www.w3.org/2001/XMLSchema-instance")); rootElem->setAttribute(X("xsi:schemaLocation"), X("com:cmcc:corporation corporation.xsd")); //add node DOMElement* prodElem = doc->createElement(X("eid")); rootElem->appendChild(prodElem); DOMText* prodDataVal = doc->createTextNode(X("100000")); prodElem->appendChild(prodDataVal); XercesDOMParser* parser = new XercesDOMParser(); //add basic child MemBufInputSource* basic_mem = new MemBufInputSource( (const XMLByte* )basic_string.c_str(), strlen(basic_string.c_str()), "basic", false); parser->parse( *basic_mem ); DOMDocument* xmlDoc = parser->getDocument(); DOMElement* basic_root = xmlDoc->getDocumentElement(); DOMNode* newnode = doc->importNode((DOMNode* )basic_root, true); rootElem->appendChild(newnode); delete basic_mem; //add the rules child MemBufInputSource* rules_mem = new MemBufInputSource( (const XMLByte* )rules_string.c_str(), rules_string.length(), "rules", false); parser->parse( *rules_mem ); xmlDoc = parser->getDocument(); DOMElement* rules_root = xmlDoc->getDocumentElement(); newnode = doc->importNode((DOMNode* )rules_root, true); rootElem->appendChild(newnode); delete rules_mem; //add the accounts child MemBufInputSource* accounts_mem = new MemBufInputSource( (const XMLByte* )accounts_string.c_str(), accounts_string.length(), "accounts", false); parser->parse( *accounts_mem ); xmlDoc = parser->getDocument(); DOMElement* accounts_root = xmlDoc->getDocumentElement(); newnode = doc->importNode((DOMNode* )accounts_root, true); rootElem->appendChild(newnode); delete accounts_mem; theSerializer->write(doc, theOutputDesc); std::cout<< target->getRawBuffer()<< std::endl; delete target; delete parser; theOutputDesc->release(); theSerializer->release(); doc->release(); } catch(const OutOfMemoryException&) { XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl; } catch (const DOMException& e) { XERCES_STD_QUALIFIER cerr << "DOMException code is: " << e.code << XERCES_STD_QUALIFIER endl; } catch (...) { XERCES_STD_QUALIFIER cerr << "An error occurred creating the document" << XERCES_STD_QUALIFIER endl; } } else { XERCES_STD_QUALIFIER cerr << "Requested implementation is not supported" << XERCES_STD_QUALIFIER endl; } XMLPlatformUtils::Terminate(); return 0; }
// MÉTODO ContentRDF :: createAction int ContentRDF:: createAction(string act, string actor, vector<string> arguments, string &content) { vector<string>::iterator it; int errorCode = 0; try { // Inicialización del sistema. XMLPlatformUtils::Initialize(); } catch(const XMLException& toCatch) { char *pMsg = XMLString::transcode(toCatch.getMessage()); XERCES_STD_QUALIFIER cerr << "Error al inicializar xerces-c.\n" << " Mensaje de excepción:" << pMsg; XMLString::release(&pMsg); return 1; }// Fin catch DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(X("Core")); if (impl != NULL) { try { // *** rdf:RDF es la raíz del mensaje. DOMDocument *action = impl->createDocument(0, X("RDF"), 0); action->setEncoding(X("UTF-8")); // *** Comentario inicial. //action->createComment(X("<?xml version=\"1.0\" standalone=\"no\">")); //action->createComment(X("<!DOCTYPE fipa-message SYSTEM \"aclRep.dtd\">")); // *** Atributos de rdf:RDF. DOMElement* rootElem = action->getDocumentElement(); rootElem->setAttribute(X("xmlnsrdf"), X("http://www.w3.org/1999/02/22-rdf-syntax.ns#")); rootElem->setAttribute(X("xmlnsfipa"), X("http://www.fipa.org/schemas/fipa-rdf0#")); DOMElement* actionElem = action->createElement(X("Action")); rootElem->appendChild(actionElem); actionElem->setAttribute(X("ID"), X((actor + "Action").c_str())); // *** Actor. DOMElement* actorElem = action->createElement(X("Actor")); actionElem->appendChild(actorElem); DOMText* actorText = action->createTextNode(X(actor.c_str())); actorElem->appendChild(actorText); // *** Act. DOMElement* actElem = action->createElement(X("Act")); actionElem->appendChild(actElem); DOMText* actText = action->createTextNode(X(act.c_str())); actElem->appendChild(actText); // *** Arguments. DOMElement* argumentsElem = action->createElement(X("Argument")); actionElem->appendChild(argumentsElem); DOMElement* bagElem = action->createElement(X("Bag")); argumentsElem->appendChild(bagElem); // Lista de argumentos. DOMElement* argumentElem; DOMText* argumentText; for (it = arguments.begin(); it != arguments.end(); it++) { argumentElem = action->createElement(X("Li")); bagElem->appendChild(argumentElem); argumentText = action->createTextNode(X((*it).c_str())); argumentElem->appendChild(argumentText); }// Fin for // Serialización a través de DOMWriter XMLCh tempStr[100]; XMLString::transcode("LS", tempStr, 99); DOMImplementation *impl = DOMImplementationRegistry::getDOMImplementation(tempStr); DOMWriter *theSerializer = ((DOMImplementationLS*)impl)->createDOMWriter(); // Conversión a string XMLCh *buf = theSerializer->writeToString(*action); char *salida = XMLString::transcode(buf); string s1(salida); content = s1; XMLString::release(&buf); XMLString::release(&salida); delete theSerializer; XMLPlatformUtils::Terminate(); }// Fin try catch (const OutOfMemoryException&) { XERCES_STD_QUALIFIER cerr << "Error debido a falta de memoria." << XERCES_STD_QUALIFIER endl; errorCode = 5; }// Fin catch catch (const DOMException& e) { XERCES_STD_QUALIFIER cerr << "DOMException en: " << e.code << XERCES_STD_QUALIFIER endl; errorCode = 2; }// Fin catch catch (...) { XERCES_STD_QUALIFIER cerr << "Se produjo un error al crear el mensaje ACL." << XERCES_STD_QUALIFIER endl; errorCode = 3; }// Fin catch }// Fin if else { XERCES_STD_QUALIFIER cerr << "La implementación requerida no está disponible." << XERCES_STD_QUALIFIER endl; errorCode = 4; }// Fin else XMLPlatformUtils::Terminate(); return errorCode; }
void writeStatFile(Tag2Html::MP3Collection* mp3Collection) { ostringstream convert; XMLPlatformUtils::Initialize(); DOMImplementation* domImplementation = DOMImplementationRegistry::getDOMImplementation(XMLString::transcode("core")); // <html> DOMDocument* doc = domImplementation->createDocument(0, XMLString::transcode("html"), 0); DOMDocumentType* docType = domImplementation->createDocumentType(XMLString::transcode("html"), XMLString::transcode(""), XMLString::transcode("")); doc->insertBefore(docType, doc->getDocumentElement()); // <head> DOMElement* head = doc->createElement(XMLString::transcode("head")); // <link rel="stylesheet" type="text/css" href="index.css"> DOMElement* headLink = doc->createElement(XMLString::transcode("link")); headLink->setAttribute(XMLString::transcode("rel"), XMLString::transcode("stylesheet")); headLink->setAttribute(XMLString::transcode("type"), XMLString::transcode("text/css")); headLink->setAttribute(XMLString::transcode("href"), XMLString::transcode("index.css")); head->appendChild(headLink); // <title>tag2html stat page</title> DOMElement* headTitle = doc->createElement(XMLString::transcode("title")); headTitle->setTextContent(XMLString::transcode("tag2html stat page")); head->appendChild(headTitle); // <meta http-equiv="Content-Type" content="text/html" charset="utf-8"> DOMElement* headMeta = doc->createElement(XMLString::transcode("meta")); headMeta->setAttribute(XMLString::transcode("http-equiv"), XMLString::transcode("Content-Type")); headMeta->setAttribute(XMLString::transcode("content"), XMLString::transcode("text/html")); headMeta->setAttribute(XMLString::transcode("charset"), XMLString::transcode("utf-8")); head->appendChild(headMeta); // <body> DOMElement* body = doc->createElement(XMLString::transcode("body")); // <br><br><br> body->appendChild(doc->createElement(XMLString::transcode("br"))); body->appendChild(doc->createElement(XMLString::transcode("br"))); body->appendChild(doc->createElement(XMLString::transcode("br"))); // <table align="center" width="300"> DOMElement* table = doc->createElement(XMLString::transcode("table")); table->setAttribute(XMLString::transcode("align"), XMLString::transcode("center")); table->setAttribute(XMLString::transcode("width"), XMLString::transcode("300")); // <tbody> DOMElement* tbody = doc->createElement(XMLString::transcode("tbody")); // <tr valign="top" bgcolor="#CCCCCC"> DOMElement* tableRow = doc->createElement(XMLString::transcode("tr")); tableRow->setAttribute(XMLString::transcode("valign"), XMLString::transcode("top")); tableRow->setAttribute(XMLString::transcode("bgcolor"), XMLString::transcode("#CCCCCC")); // <td align="center"> DOMElement* tableColumn = doc->createElement(XMLString::transcode("td")); tableColumn->setAttribute(XMLString::transcode("align"), XMLString::transcode("center")); tableRow->appendChild(tableColumn); // <b>Statistics</b> DOMElement* columnStatistics = doc->createElement(XMLString::transcode("b")); columnStatistics->setTextContent(XMLString::transcode("Statistics")); tableColumn->appendChild(columnStatistics); // <tr> DOMElement* tableRow2 = doc->createElement(XMLString::transcode("tr")); // <td> DOMElement* tableColumn2 = doc->createElement(XMLString::transcode("td")); // <table class="nb"> DOMElement* innerTable = doc->createElement(XMLString::transcode("table")); innerTable->setAttribute(XMLString::transcode("class"), XMLString::transcode("nb")); // <tr> DOMElement* rowFileType = doc->createElement(XMLString::transcode("tr")); // <td style="font-weight: bold;">File Type:</td> DOMElement* columnFileType = doc->createElement(XMLString::transcode("td")); columnFileType->setAttribute(XMLString::transcode("style"), XMLString::transcode("font-weight: bold;")); columnFileType->setTextContent(XMLString::transcode("File Type:")); rowFileType->appendChild(columnFileType); // <td>MP3</td> DOMElement* columnFileTypeValue = doc->createElement(XMLString::transcode("td")); columnFileTypeValue->setTextContent(XMLString::transcode("MP3")); rowFileType->appendChild(columnFileTypeValue); // <tr> DOMElement* rowFileCount = doc->createElement(XMLString::transcode("tr")); // <td style="font-weight: bold;">File Count:</td> DOMElement* columnFileCount = doc->createElement(XMLString::transcode("td")); columnFileCount->setAttribute(XMLString::transcode("style"), XMLString::transcode("font-weight: bold;")); columnFileCount->setTextContent(XMLString::transcode("File Count:")); rowFileCount->appendChild(columnFileCount); // <td>" << mystat->mp3_count << "</td> DOMElement* columnFileCountValue = doc->createElement(XMLString::transcode("td")); convert.str(""); convert << mp3Collection->items.size(); columnFileCountValue->setTextContent(XMLString::transcode(convert.str().c_str())); rowFileCount->appendChild(columnFileCountValue); // <tr>\n"; DOMElement* rowArtistCount = doc->createElement(XMLString::transcode("tr")); // <td style="font-weight: bold;">Artist Count:</td> DOMElement* columnArtistCount = doc->createElement(XMLString::transcode("td")); columnArtistCount->setAttribute(XMLString::transcode("style"), XMLString::transcode("font-weight: bold;")); columnArtistCount->setTextContent(XMLString::transcode("Artist Count:")); rowArtistCount->appendChild(columnArtistCount); // <td>" << mystat->art_count << "</td> DOMElement* columnArtistCountValue = doc->createElement(XMLString::transcode("td")); convert.str(""); convert << mp3Collection->getArtistCount(); columnArtistCountValue->setTextContent(XMLString::transcode(convert.str().c_str())); rowArtistCount->appendChild(columnArtistCountValue); // <tr> DOMElement* rowAlbumCount = doc->createElement(XMLString::transcode("tr")); // <td style="font-weight: bold;">Album Count:</td> DOMElement* columnAlbumCount = doc->createElement(XMLString::transcode("td")); columnAlbumCount->setAttribute(XMLString::transcode("style"), XMLString::transcode("font-weight: bold;")); columnAlbumCount->setTextContent(XMLString::transcode("Album Count:")); rowAlbumCount->appendChild(columnAlbumCount); // <td>" << mystat->alb_count << "</td> DOMElement* columnAlbumCountValue = doc->createElement(XMLString::transcode("td")); convert.str(""); convert << mp3Collection->getAlbumCount(); columnAlbumCountValue->setTextContent(XMLString::transcode(convert.str().c_str())); rowAlbumCount->appendChild(columnAlbumCountValue); // <tr> DOMElement* rowTotalSize = doc->createElement(XMLString::transcode("tr")); // <td style="font-weight: bold;">Total Size:</td> DOMElement* columnTotalSize = doc->createElement(XMLString::transcode("td")); columnTotalSize->setAttribute(XMLString::transcode("style"), XMLString::transcode("font-weight: bold;")); columnTotalSize->setTextContent(XMLString::transcode("Total Filesize:")); rowTotalSize->appendChild(columnTotalSize); // <td>" << ( mystat->tot_filesize/(1024*1024)) << " MByte</td> DOMElement* columnTotalSizeValue = doc->createElement(XMLString::transcode("td")); convert.str(""); convert << (mp3Collection->getTotalFilesize() / 1024 / 1024) << " MB"; columnTotalSizeValue->setTextContent(XMLString::transcode(convert.str().c_str())); rowTotalSize->appendChild(columnTotalSizeValue); // <tr> DOMElement* rowTotalLength = doc->createElement(XMLString::transcode("tr")); // <td style="font-weight: bold;">Total Length:</td> DOMElement* columnTotalLength = doc->createElement(XMLString::transcode("td")); columnTotalLength->setAttribute(XMLString::transcode("style"), XMLString::transcode("font-weight: bold;")); columnTotalLength->setTextContent(XMLString::transcode("Total Length:")); rowTotalLength->appendChild(columnTotalLength); // <td> ~ " << mystat->tot_length << "</td> DOMElement* columnTotalLengthValue = doc->createElement(XMLString::transcode("td")); convert.str(""); char statLength[12]; struct tm* timeinfo = new tm(); int seconds = mp3Collection->getTotalLength(); if (seconds >= 60) { int minutes = seconds / 60; if (minutes >= 60) { timeinfo->tm_hour = minutes / 60; timeinfo->tm_min = minutes / 60; } else { timeinfo->tm_min = seconds / 60; } } timeinfo->tm_sec = seconds % 60; strftime(statLength, 12, "%H:%M:%S", timeinfo); columnTotalLengthValue->setTextContent(XMLString::transcode(statLength)); rowTotalLength->appendChild(columnTotalLengthValue); innerTable->appendChild(rowFileType); innerTable->appendChild(rowFileCount); innerTable->appendChild(rowArtistCount); innerTable->appendChild(rowAlbumCount); innerTable->appendChild(rowTotalSize); innerTable->appendChild(rowTotalLength); tableColumn2->appendChild(innerTable); tableRow2->appendChild(tableColumn2); tbody->appendChild(tableRow); tbody->appendChild(tableRow2); table->appendChild(tbody); body->appendChild(table); doc->getDocumentElement()->appendChild(head); doc->getDocumentElement()->appendChild(body); DOMWriter* writer = ((DOMImplementationLS*)domImplementation)->createDOMWriter(); if (writer->canSetFeature(XMLUni::fgDOMWRTFormatPrettyPrint, true)) { writer->setFeature(XMLUni::fgDOMWRTFormatPrettyPrint, true); } if (writer->canSetFeature(XMLUni::fgDOMXMLDeclaration, false)) { writer->setFeature(XMLUni::fgDOMXMLDeclaration, false); } XMLFormatTarget *fileFormatTarget = new LocalFileFormatTarget("stats.html"); writer->writeNode(fileFormatTarget, *doc); fileFormatTarget->flush(); writer->release(); doc->release(); XMLPlatformUtils::Terminate(); }