bool serializeDOM(std::ostream& output, bool) { XMLCh tempStr[100]; XMLString::transcode("LS", tempStr, 99); DOMImplementationLS *impl = dynamic_cast<DOMImplementationLS *>(DOMImplementationRegistry::getDOMImplementation(tempStr)); DOMLSSerializer *theSerializer = impl->createLSSerializer(); DOMLSOutput *theOutputDesc = impl->createLSOutput(); bool rc = false; try { MemBufFormatTarget *myFormTarget = new MemBufFormatTarget(); /* do the serialization through DOMLSSerializer::write(); */ theOutputDesc->setByteStream(myFormTarget); theSerializer->write(inputFileDOM, theOutputDesc); const XMLByte * data = myFormTarget->getRawBuffer(); XMLSize_t len = myFormTarget->getLen(); output.write( reinterpret_cast<const char *>(data), len ); delete myFormTarget; rc = true; } catch (IOException& e ) { cerr << StrX(e.getMessage()); cerr << " Code is " << e.getCode(); if ( errno != 0 ) { cerr << ": " << strerror( errno ); } } catch (XMLException& e) { cerr << "An error occurred during creation of output transcoder. Msg is:" << endl << StrX(e.getMessage()); if ( errno != 0 ) { cerr << ": " << strerror( errno ); } cerr << endl; rc = false; } delete theSerializer; return rc; }
/// Dump DOM tree using XercesC handles void dumpTree(DOMNode* doc, ostream& os) { if ( doc ) { DOMImplementation *imp = DOMImplementationRegistry::getDOMImplementation(Strng_t("LS")); MemBufFormatTarget *tar = new MemBufFormatTarget(); DOMLSOutput *out = imp->createLSOutput(); DOMLSSerializer *wrt = imp->createLSSerializer(); out->setByteStream(tar); wrt->getDomConfig()->setParameter(Strng_t("format-pretty-print"), true); wrt->write(doc, out); os << tar->getRawBuffer() << endl << flush; out->release(); wrt->release(); return; } printout(ERROR,"dumpTree","+++ Cannot dump invalid document."); }
bool ServerConfigXMLReader::readServerConfig(const std::string & path) { this->serverConfig = ServerConfig(); try { XMLPlatformUtils::Initialize(); } catch (const XMLException& toCatch) { char * message = XMLString::transcode(toCatch.getMessage()); cout << "Error during initialization! :\n" << message << "\n"; XMLString::release(&message); return false; } XercesDOMParser * parser = new XercesDOMParser(); //parser->setValidationScheme(XercesDOMParser::Val_Auto); parser->setDoNamespaces(true); parser->setDoXInclude(true); //parser->setValidationScheme(XercesDOMParser::Val_Always); // parser->setDoSchema(true); // parser->setValidationSchemaFullChecking(true); XMLParseErrorReporter * xmlParseErrorReporter = new XMLParseErrorReporter();; parser->setErrorHandler(xmlParseErrorReporter); try { parser->parse(path.c_str()); } catch (const XMLException & toCatch) { char * message = XMLString::transcode(toCatch.getMessage()); cout << "Exception message is: \n" << message << "\n"; XMLString::release(&message); return false; } catch (const DOMException& toCatch) { char * message = XMLString::transcode(toCatch.msg); cout << "Exception message is: \n" << message << "\n"; XMLString::release(&message); return false; } catch (...) { cout << "Unexpected Exception \n" ; return false; } DOMDocument * domDocument = parser->getDocument(); removeBaseAttr(domDocument); // get a serializer, an instance of DOMLSSerializer XMLCh tempStr[3] = {chLatin_L, chLatin_S, chNull}; DOMImplementation *impl = DOMImplementationRegistry::getDOMImplementation(tempStr); DOMLSSerializer *theSerializer = ((DOMImplementationLS*)impl)->createLSSerializer(); DOMLSOutput *theOutputDesc = ((DOMImplementationLS*)impl)->createLSOutput(); // set user specified output encoding theOutputDesc->setEncoding(0); XMLDOMErrorReporter * xmlDOMErrorReporter = new XMLDOMErrorReporter(); DOMConfiguration * serializerConfig = theSerializer->getDomConfig(); serializerConfig->setParameter(XMLUni::fgDOMErrorHandler, xmlDOMErrorReporter); // set feature if the serializer supports the feature/mode if (serializerConfig->canSetParameter(XMLUni::fgDOMWRTSplitCdataSections, true)) serializerConfig->setParameter(XMLUni::fgDOMWRTSplitCdataSections, true); if (serializerConfig->canSetParameter(XMLUni::fgDOMWRTDiscardDefaultContent, true)) serializerConfig->setParameter(XMLUni::fgDOMWRTDiscardDefaultContent, true); if (serializerConfig->canSetParameter(XMLUni::fgDOMWRTFormatPrettyPrint, false)) serializerConfig->setParameter(XMLUni::fgDOMWRTFormatPrettyPrint, false); if (serializerConfig->canSetParameter(XMLUni::fgDOMWRTBOM, false)) serializerConfig->setParameter(XMLUni::fgDOMWRTBOM, false); /* XMLFormatTarget * myFormTarget = new StdOutFormatTarget(); theOutputDesc->setByteStream(myFormTarget); theSerializer->write(domDocument, theOutputDesc); */ MemBufFormatTarget * myFormTarget = new MemBufFormatTarget(); theOutputDesc->setByteStream(myFormTarget); theSerializer->write(domDocument, theOutputDesc); /* XMLFormatTarget * myFormTarget2 = new StdOutFormatTarget(); theOutputDesc->setByteStream(myFormTarget2); theSerializer->write(domDocument, theOutputDesc); */ MemBufInputSource * memInput = new MemBufInputSource(myFormTarget->getRawBuffer(), myFormTarget->getLen(), path.c_str()); XercesDOMParser * parser2 = new XercesDOMParser(); parser2->setDoNamespaces(true); parser2->setDoXInclude(true); // parser2->setValidationScheme(XercesDOMParser::Val_Always); // parser2->setDoSchema(true); // parser2->setValidationSchemaFullChecking(true); parser2->setErrorHandler(xmlParseErrorReporter); try { parser2->parse(*memInput); } catch (const XMLException & toCatch) { char * message = XMLString::transcode(toCatch.getMessage()); cout << "Exception message is: \n" << message << "\n"; XMLString::release(&message); return false; } catch (const DOMException& toCatch) { char * message = XMLString::transcode(toCatch.msg); cout << "Exception message is: \n" << message << "\n"; XMLString::release(&message); return false; } catch (...) { cout << "Unexpected Exception \n" ; return false; } DOMDocument * domDocument2 = parser2->getDocument(); XMLNodeFilter * xmlNodeFilter = new XMLNodeFilter(); DOMTreeWalker * domTreeWalker = domDocument->createTreeWalker(domDocument2, DOMNodeFilter::SHOW_ALL, xmlNodeFilter, true); this->serverConfig = extractServerConfig(domDocument2, domTreeWalker); domTreeWalker->release(); delete xmlNodeFilter; delete xmlDOMErrorReporter; delete xmlParseErrorReporter; delete parser; XMLPlatformUtils::Terminate(); return true; }
/*! \brief It gets a list of DOM nodes containing a protocol, and formats them into _nbPDMLProto structures. This function converts each protocol and all its child fields. This function will call the FormatFieldsItem() for this purpose. \param PDMLDocument The DOMDocument associated to the current PDML packet. \return The number of '<proto>' that have been copied in the returned buffer, nbFAILURE if some error occurred. The error message is stored in the m_errbuf internal buffer. */ int CPDMLReader::FormatProtoItem(DOMDocument *PDMLDocument) { DOMNodeList *ProtoList; XMLCh TempBuffer[NETPDL_MAX_STRING + 1]; unsigned int ProtoNumber; unsigned int TotNumProto; XMLString::transcode(PDML_PROTO, TempBuffer, NETPDL_MAX_STRING); // After parsing the '<packet>' fragment, let's list the <proto> contained into it ProtoList= PDMLDocument->getElementsByTagName(TempBuffer); // Get the number of protocols contained in this packet TotNumProto= ProtoList->getLength(); // Check if the protocol structures allocated previously are enough. If not, let's allocate new structures if (TotNumProto >= m_maxNumProto) { if (UpdateProtoList(&m_maxNumProto, &m_protoList, m_errbuf, sizeof(m_errbuf)) == nbFAILURE) return nbFAILURE; } // Reset the buffer m_asciiBuffer.ClearBuffer(false /* resizing not permitted */); for (ProtoNumber= 0; ProtoNumber < TotNumProto; ProtoNumber++) { DOMElement *ProtoItem; // Set everything to zero memset(m_protoList[ProtoNumber], 0, sizeof(_nbPDMLProto)); // Update pointer to the packet summary m_protoList[ProtoNumber]->PacketSummary= &m_packetSummary; // Updates the protocol chain if (ProtoNumber >= 1) { m_protoList[ProtoNumber - 1]->NextProto= m_protoList[ProtoNumber]; m_protoList[ProtoNumber]->PreviousProto= m_protoList[ProtoNumber - 1]; } ProtoItem= (DOMElement *) ProtoList->item(ProtoNumber); // Copies all the attributes of this proto in the new structure if (AppendItemString(ProtoItem, PDML_FIELD_ATTR_NAME, &(m_protoList[ProtoNumber]->Name), &m_asciiBuffer, m_errbuf, sizeof(m_errbuf)) == nbFAILURE) return nbFAILURE; if (AppendItemString(ProtoItem, PDML_FIELD_ATTR_LONGNAME, &(m_protoList[ProtoNumber]->LongName), &m_asciiBuffer, m_errbuf, sizeof(m_errbuf)) == nbFAILURE) return nbFAILURE; if (AppendItemLong(ProtoItem, PDML_FIELD_ATTR_SIZE, &(m_protoList[ProtoNumber]->Size), m_errbuf, sizeof(m_errbuf)) == nbFAILURE) return nbFAILURE; if (AppendItemLong(ProtoItem, PDML_FIELD_ATTR_POSITION, &(m_protoList[ProtoNumber]->Position), m_errbuf, sizeof(m_errbuf)) == nbFAILURE) return nbFAILURE; #ifdef DOM_DEBUG // FULVIO This code is still present, because it should be needed in order to solve // a bug discovered on Dec 4, 2006 // See my email in the mailbox // 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(); MemBufFormatTarget myFormTarget; theSerializer->writeNode(&myFormTarget, *ProtoItem); const XMLByte *Result= myFormTarget.getRawBuffer(); delete theSerializer; #endif if (ProtoItem->hasChildNodes() ) { if (FormatFieldNodes(ProtoItem->getFirstChild(), m_protoList[ProtoNumber], NULL) == nbFAILURE) return nbFAILURE; } } // Update the pointer to the first protocol if (TotNumProto > 0) m_packetSummary.FirstProto= m_protoList[0]; else m_packetSummary.FirstProto= NULL; return (int) ProtoNumber; }
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; }