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();
}
