自学教程：C++ xmlFreeTextWriter函数代码示例

void queryMacroFileProvider::SaveMacros(queryMacroList *macros){	xmlTextWriterPtr writer;	writer = xmlNewTextWriterFilename((const char *)settings->GetMacrosFile().mb_str(wxConvUTF8), 0);	if (!writer)	{		wxMessageBox(_("Failed to open macros file!"));		return;	}	xmlTextWriterSetIndent(writer, 1);	if ((xmlTextWriterStartDocument(writer, NULL, "UTF-8", NULL) < 0) ||	        (xmlTextWriterStartElement(writer, XML_STR("macros")) < 0))	{		wxMessageBox(_("Failed to write to macros file!"));		xmlFreeTextWriter(writer);		return;	}	((queryMacroList *)macros)->saveList(writer);	if (xmlTextWriterEndDocument(writer) < -1)	{		wxMessageBox(_("Failed to write to macros file!"));	}	xmlFreeTextWriter(writer);}

void queryFavouriteFileProvider::SaveFavourites(queryFavouriteFolder *favourites){	xmlTextWriterPtr writer;	writer = xmlNewTextWriterFilename((const char *)settings->GetFavouritesFile().mb_str(wxConvUTF8), 0);	if (!writer)	{		wxMessageBox(_("Failed to write to favourites file!"));		return;	}	xmlTextWriterSetIndent(writer, 1);	if ((xmlTextWriterStartDocument(writer, NULL, "UTF-8", NULL) < 0) ||	        (xmlTextWriterStartElement(writer, XML_STR("favourites")) < 0))	{		wxMessageBox(_("Failed to write to favourites file!"));		xmlFreeTextWriter(writer);		return;	}	((queryFavouriteFolder *)favourites)->saveFolder(writer);	if (xmlTextWriterEndDocument(writer) < 0)	{		wxMessageBox(_("Failed to write to favourites file!"));	}	xmlFreeTextWriter(writer);}

int write_volumeindex(opendcp_t *opendcp) {    xmlIndentTreeOutput = 1;    xmlDocPtr        doc;    xmlTextWriterPtr xml;    int              rc;    dcp_log(LOG_INFO,"Writing VOLINDEX file %.256s",opendcp->volindex.filename);    /* create XML document */    xml = xmlNewTextWriterDoc(&doc,0);    /* volumeindex XML Start */    rc = xmlTextWriterStartDocument(xml, NULL, XML_ENCODING, NULL);    if (rc < 0) {        dcp_log(LOG_ERROR,"xmlTextWriterStartDocument failed");        return DCP_FATAL;    }    xmlTextWriterStartElement(xml, BAD_CAST "VolumeIndex");    xmlTextWriterWriteAttribute(xml, BAD_CAST "xmlns", BAD_CAST NS_AM[opendcp->ns]);    xmlTextWriterWriteFormatElement(xml, BAD_CAST "Index","%d",1);    xmlTextWriterEndElement(xml);     rc = xmlTextWriterEndDocument(xml);    if (rc < 0) {        dcp_log(LOG_ERROR,"xmlTextWriterEndDocument failed %s",opendcp->volindex.filename);        return DCP_FATAL;    }    xmlFreeTextWriter(xml);    xmlSaveFormatFile(opendcp->volindex.filename, doc, 1);    xmlFreeDoc(doc);    return DCP_SUCCESS;}

/* Private exporting functions cpe_*<structure>*_export( xmlTextWriterPtr ) * More info in representive header file. * returns the type of <structure> */void cpe_lang_model_export_xml(const struct cpe_lang_model *spec, const char *file){	__attribute__nonnull__(spec);	__attribute__nonnull__(file);	// TODO: ad macro to check return value from xmlTextWriter* functions	xmlTextWriterPtr writer;	writer = xmlNewTextWriterFilename(file, 0);	if (writer == NULL) {		oscap_setxmlerr(xmlGetLastError());		return;	}	// Set properties of writer TODO: make public function to edit this ??	xmlTextWriterSetIndent(writer, 1);	xmlTextWriterSetIndentString(writer, BAD_CAST "    ");	xmlTextWriterStartDocument(writer, NULL, "UTF-8", NULL);	cpe_lang_export(spec, writer);	xmlTextWriterEndDocument(writer);	xmlFreeTextWriter(writer);	if (xmlGetLastError() != NULL)		oscap_setxmlerr(xmlGetLastError());}

bool TasksetWriter::write(const std::string& filename, vector<Task*>& taskset) const {    xmlDocPtr doc;    tDebug() << "Writing Taskset to XML file: " << filename;    xmlTextWriterPtr writer;    writer = xmlNewTextWriterDoc(&doc, 0);    xmlTextWriterSetIndent(writer, 1);    if (xmlTextWriterSetIndentString(writer, (const xmlChar*) "  ") != 0) {        tError() << "Fehler beim Setzen des Einrueckens!";    }    xmlTextWriterStartDocument(writer, NULL, "UTF-8", NULL);    xmlTextWriterWriteComment(writer, (xmlChar*) "Hier kommen die Tasks");    xmlTextWriterStartElement(writer, (xmlChar*) "taskset");    xmlTextWriterWriteAttributeNS(writer, (xmlChar*) "xsi", (xmlChar*) "schemaLocation", (xmlChar*) "http://www.w3.org/2001/XMLSchema-instance", (xmlChar*) "http://www.tmsxmlns.com taskset.xsd");    xmlTextWriterWriteAttribute(writer, (xmlChar*) "xmlns", (xmlChar*) "http://www.tmsxmlns.com");    xmlTextWriterWriteRaw(writer, (xmlChar*) "/n");    for (size_t i = 0; i < taskset.size(); i++) {        xmlTextWriterWriteRaw(writer, (xmlChar*) "/n");        //taskset[i]->write(writer);        taskset[i]->writeToXML(writer);        xmlTextWriterWriteRaw(writer, (xmlChar*) "/n");    }    xmlTextWriterEndElement(writer); // close TaskSet    xmlTextWriterEndDocument(writer);    xmlFreeTextWriter(writer);    xmlSaveFile(filename.c_str(), doc);    xmlNodePtr cur = xmlDocGetRootElement(doc);    if (cur == NULL) {        tError() << "Empty document.";        xmlFreeDoc(doc);        return false;    }    if (xmlStrcmp(cur->name, (const xmlChar *) "taskset")) {        tError() << "Document of the wrong type, root node != taskset";        xmlFreeDoc(doc);        return false;    }    if (isValid(doc) > 0) {        tDebug() << "Written document is valid";    } else {        tError() << "Written document is invalid";        xmlFreeDoc(doc);        return false;    }    xmlFreeDoc(doc);    return true;}

 ResultWriter::~ResultWriter() {   if(writer_ != nullptr){     // free the writer     xmlFreeTextWriter(writer_);   }   xmlCleanupParser(); }

void DFSerializeXMLBuffer(DFDocument *doc, NamespaceID defaultNS, int indent, DFBuffer *buf){    xmlOutputBufferPtr output = xmlOutputBufferCreateIO(StringBufferWrite,                                                        StringBufferClose,                                                        buf,                                                        NULL);    xmlTextWriterPtr writer = xmlNewTextWriter(output);    int html = 0;    for (DFNode *child = doc->docNode->first; child != NULL; child = child->next) {        if (child->tag == HTML_HTML)            html = 1;    }    Serialization serialization;    bzero(&serialization,sizeof(serialization));    serialization.ic = iconv_open("UTF-8","UTF-16LE");    if (serialization.ic == ((iconv_t)-1)) {        fprintf(stderr,"FATAL: Can't open iconv descriptor/n");        abort();    }    serialization.writer = writer;    serialization.doc = doc;    serialization.defaultNS = defaultNS;    serialization.html = html;    serialization.indent = indent;    writeNode(&serialization,doc->docNode,0);    iconv_close(serialization.ic);    xmlFreeTextWriter(writer);}

int generate_report(char dst_dir[DIR_LENGTH_MAX], char filename[FILENAME_LENGTH_MAX]) {	// for the xml writer, refer to http://xmlsoft.org/html/libxml-xmlwriter.html 		char dst_file[FILENAME_LENGTH_MAX + DIR_LENGTH_MAX] = "";	strcat(dst_file, dst_dir);	strcat(dst_file, filename);		xmlTextWriterPtr writer;	writer = xmlNewTextWriterFilename(dst_file, 0);		// set the output format of the XML file 	xmlTextWriterSetIndent(writer, 1);	xmlTextWriterSetIndentString(writer, "	");	xmlTextWriterStartDocument(writer, NULL, NULL, NULL);    /* Write an element named "X_ORDER_ID" as child of HEADER. */   xmlTextWriterWriteFormatElement(writer, "COMMENT           ", "	in this output file, %d means NOT_PROCESSED; %d means NO_FILE; %d means ERROR; %d means OK	", MODULE_NOT_PROCESSED, NO_FILE, MODULE_ERROR, MODULE_OK);	xmlTextWriterWriteFormatElement(writer, "OCG_GET_OPT       ", "	%d	", get_opt_OK);	xmlTextWriterWriteFormatElement(writer, "OCG_DETECT_FILE   ", "	%d	", detect_file_OK);	xmlTextWriterWriteFormatElement(writer, "OCG_PARSE_FILENAME", "	%d	", parse_filename_OK);	xmlTextWriterWriteFormatElement(writer, "OCG_CREATE_DIR    ", "	%d	", create_dir_OK);	xmlTextWriterWriteFormatElement(writer, "OCG_PARSE_XML     ", "	%d	", parse_XML_OK);	xmlTextWriterWriteFormatElement(writer, "OCG_SAVE_XML      ", "	%d	", save_XML_OK);//	xmlTextWriterWriteFormatElement(writer, "OCG_CALL_EMU      ", "	%d	", call_emu_OK);	xmlTextWriterEndDocument(writer);	xmlFreeTextWriter(writer);	LOG_I(OCG, "A report of OCG is generated in directory /"%s/"/n/n", dst_dir);	return MODULE_OK;}

std::string XMLSchema::xml() const{    xmlBuffer *b = xmlBufferCreate();    xmlTextWriterPtr w = xmlNewTextWriterMemory(b, 0);    xmlTextWriterSetIndent(w, 1);    xmlTextWriterStartDocument(w, NULL, "utf-8", NULL);    xmlTextWriterStartElementNS(w, (const xmlChar*)"pc",        (const xmlChar*)"PointCloudSchema", NULL);    xmlTextWriterWriteAttributeNS(w, (const xmlChar*) "xmlns",        (const xmlChar*)"pc", NULL,        (const xmlChar*)"http://pointcloud.org/schemas/PC/");    xmlTextWriterWriteAttributeNS(w, (const xmlChar*)"xmlns",        (const xmlChar*)"xsi", NULL,        (const xmlChar*)"http://www.w3.org/2001/XMLSchema-instance");    writeXml(w);    xmlTextWriterEndElement(w);    xmlTextWriterEndDocument(w);    std::string output((const char *)b->content, b->use);    xmlFreeTextWriter(w);    xmlBufferFree(b);    return output;}

void XMLExporter::close(){	//xmlTextWriterEndElement(m_writer);	xmlFreeTextWriter(m_writer);	xmlSaveFormatFileEnc(m_file.c_str(), m_doc, MY_ENCODING, 1); 	xmlCleanupParser();	xmlMemoryDump();}

static void cleanupSBOLWriter() {	xmlFreeTextWriter(WRITER);	xmlFreeDoc(OUTPUT);	WRITER = NULL;	OUTPUT = NULL;	deletePointerArray(PROCESSED);	PROCESSED = NULL;	xmlCleanupParser();}

  ~LibXmlStuff() {    if (xpath_context)      xmlXPathFreeContext(xpath_context);    if (reader)      xmlFreeTextReader(reader);    if (writer)      xmlFreeTextWriter(writer);  }

static void writexml(const char *name){	mode = 'w';	writer = xmlNewTextWriterFilename(name, 0);	xmlTextWriterStartDocument(writer, NULL, "UTF-8", NULL);	startnode("root");	all_decl();	endnode();	xmlFreeTextWriter(writer);}

cpXmlCmdOutput::~cpXmlCmdOutput(){    /* Here we could close open elements but since we do not want to     * write any other elements, we simply call xmlTextWriterEndDocument,     * which will do all the work */    if ( xmlTextWriterEndDocument( writer ) < 0 )       throw ::std::runtime_error( "Error ending to the output document" );    xmlFreeTextWriter( writer );}

void Free_Writer(CXMLWRITER *test){	if (test->writer)	{		xmlTextWriterEndDocument(test->writer);		xmlFreeTextWriter(test->writer);		test->writer=NULL;	}	if (test->buffer) xmlBufferFree(test->buffer);	test->buffer=NULL;}

c_XMLWriter::~c_XMLWriter() {  if (m_ptr) {    xmlFreeTextWriter(m_ptr);  }  if (m_output) {    xmlBufferFree(m_output);  }  if (m_uri_output) {    xmlOutputBufferClose(m_uri_output);  }}

//----------------------------------------------------------------------------// Finished a file and saves it//----------------------------------------------------------------------------void CXMLTreeNode::EndNewFile (){  assert(m_pWriter && m_pDoc && m_pszFileName);  if (m_pWriter && m_pDoc && m_pszFileName)  {    xmlFreeTextWriter(m_pWriter);    m_pWriter = NULL;    xmlSaveFileEnc(m_pszFileName, m_pDoc, MY_ENCODING);  }}

void XMLInOut::DeleteDoc(void){	if (writer)	    xmlFreeTextWriter(writer);	if (buf)	    xmlBufferFree(buf);	writer = NULL;	buf = NULL;	sections.clear();}

/** * @brief Saves all the star planets. * *    @return 0 on success. */int dpl_saveAll (void){    int i;    /*char file[PATH_MAX];*/    xmlDocPtr doc;    xmlTextWriterPtr writer;    int np;    const Planet *p;    const Planet **sorted_p;    /* Create the writer. */    writer = xmlNewTextWriterDoc(&doc, 0);    if (writer == NULL) {        WARN("testXmlwriterDoc: Error creating the xml writer");        return -1;    }    /* Set the writer parameters. */    xmlw_setParams( writer );    /* Start writer. */    xmlw_start(writer);    xmlw_startElem( writer, "Assets" );    /* Sort planets. */    p        = planet_getAll( &np );    sorted_p = malloc( sizeof(Planet*) * np );    for (i=0; i<np; i++)        sorted_p[i]  = &p[i];    qsort( sorted_p, np, sizeof(Planet*), dpl_compPlanet );    /* Write planets. */    for (i=0; i<np; i++)        dpl_savePlanet( writer, sorted_p[i] );    /* Clean up sorted planet.s */    free(sorted_p);    /* End writer. */    xmlw_endElem( writer ); /* "Assets" */    xmlw_done( writer );    /* No need for writer anymore. */    xmlFreeTextWriter( writer );    /* Write data. */    xmlSaveFileEnc( "asset.xml", doc, "UTF-8" );    /* Clean up. */    xmlFreeDoc(doc);    return 0;}

// SAX save settingsshort int settingsXmlSave(const char *filename) {    int rc;    xmlTextWriterPtr writer;    // Create a new XmlWriter with no compression    writer = xmlNewTextWriterFilename(filename, 0);    if (writer == NULL) return 1;    // Start document with xml default encoding ISO 8859-1    rc = xmlTextWriterStartDocument(writer, NULL, XML_ENCODING, NULL);    if (rc < 0) return 2;    // Start root node "settings"    rc = xmlTextWriterStartElement(writer, BAD_CAST "settings");    if (rc < 0) return 2;	// Create child node "xap"    rc = xmlTextWriterStartElement(writer, BAD_CAST "xap");    if (rc < 0) return 2;    	// Write <xap> elements    rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "iface", "%s", hubConfig->interfacename);	if (rc < 0) return 4;	rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "instance", "%s", hubConfig->xap_addr.instance);	if (rc < 0) return 4;    rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "hbeatf", "%d", hubConfig->xap_hbeat);    if (rc < 0) return 4;	rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "uid", "%s", hubConfig->xap_uid);    if (rc < 0) return 4;    rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "port", "%d", hubConfig->xap_port);    if (rc < 0) return 4;                // Close node "xap"    rc = xmlTextWriterEndElement(writer);    if (rc < 0) return 5;        // Close the rest nodes pending to close    rc = xmlTextWriterEndDocument(writer);	if (rc < 0) return 5;	// Free the writer    xmlFreeTextWriter(writer);        // Cleanup function for the XML library.    xmlCleanupParser();        // this is to debug memory for regression tests    xmlMemoryDump();        return 0;}

  XMLConversion::~XMLConversion()  {    if(_reader) {      xmlFreeTextReader(_reader);      _reader = NULL;    }    if(_writer) {//      xmlTextWriterEndDocument(_writer); //if hasn't been called ealier        xmlFreeTextWriter(_writer);// was crashing        _writer = NULL;    }    //xmlBufferFree(_buf);  }

/** * @short Prepares the response for propfinds *  * @param realpath Shared folder * @param urlpath URL of the requested propfind * @param depth Depth of query, 0 or 1. * @param props Properties of the query *  * @returns An onion_block with the XML data. */onion_block *onion_webdav_write_propfind(const char *basepath, const char *realpath, const char *urlpath, int depth, 																				 int props){	onion_block *data=onion_block_new();	xmlTextWriterPtr writer;	xmlBufferPtr buf;	buf = xmlBufferCreate();	if (buf == NULL) {		ONION_ERROR("testXmlwriterMemory: Error creating the xml buffer");		return data;	}	writer = xmlNewTextWriterMemory(buf, 0);	if (writer == NULL) {		ONION_ERROR("testXmlwriterMemory: Error creating the xml writer");		return data;	}	int error;	xmlTextWriterStartDocument(writer, NULL, "utf-8", NULL);	xmlTextWriterStartElement(writer, BAD_CAST "D:multistatus");		xmlTextWriterWriteAttribute(writer, BAD_CAST "xmlns:D" ,BAD_CAST "DAV:");			error=onion_webdav_write_props(writer, basepath, realpath, urlpath, NULL, props);			if (depth>0){				ONION_DEBUG("Get also all files");				DIR *dir=opendir(realpath);				if (!dir){					ONION_ERROR("Error opening dir %s to check files on it", realpath);				}				else{					struct dirent *de;					while ( (de=readdir(dir)) ){						if (de->d_name[0]!='.')							onion_webdav_write_props(writer, basepath, realpath, urlpath, de->d_name, props);					}					closedir(dir);				}			}		xmlTextWriterEndElement(writer);	xmlTextWriterEndElement(writer);			xmlTextWriterEndDocument(writer);	xmlFreeTextWriter(writer);		onion_block_add_str(data, (const char*)buf->content);	xmlBufferFree(buf);	if (error){		onion_block_free(data);		return NULL;	}	return data;}

void temporal_convert_parallel_passages()// This was used to convert file NT_order_of_OT_Quotations_in_NT.pps to xml.// Then for converting NT_Parallel_Passages.pps.// Then for converting OT_Parallel_Passages.pps.{  bool set_opened = false;  xmlBufferPtr buffer = xmlBufferCreate();  xmlTextWriterPtr writer = xmlNewTextWriterMemory(buffer, 0);  xmlTextWriterStartDocument(writer, NULL, "UTF-8", NULL);  xmlTextWriterSetIndent(writer, 1);  xmlTextWriterStartElement(writer, BAD_CAST "ot-parallel-passages");  ReadText rt("/home/joe/parallel-passages/OT_Parallel_Passages.pps", true);  for (unsigned int i = 0; i < rt.lines.size(); i++) {    if (rt.lines[i].find("//key ") == 0) {      rt.lines[i].erase(0, 5);      xmlTextWriterStartElement(writer, BAD_CAST "section");      xmlTextWriterWriteAttribute(writer, BAD_CAST "title", BAD_CAST rt.lines[i].c_str());    }    if (rt.lines[i].find("//ref ") == 0) {      if (!set_opened) {        xmlTextWriterStartElement(writer, BAD_CAST "set");        set_opened = true;      }      xmlTextWriterStartElement(writer, BAD_CAST "reference");      rt.lines[i].erase(0, 5);      ustring book, chapter, verse;      decode_reference(rt.lines[i], book, chapter, verse);      book = books_id_to_english(books_paratext_to_id(book));      xmlTextWriterWriteAttribute(writer, BAD_CAST "book", BAD_CAST book.c_str());      xmlTextWriterWriteAttribute(writer, BAD_CAST "chapter", BAD_CAST chapter.c_str());      xmlTextWriterWriteAttribute(writer, BAD_CAST "verse", BAD_CAST verse.c_str());      xmlTextWriterEndElement(writer);    }    if (rt.lines[i].empty() || (rt.lines[i].find("//com") == 0)) {      xmlTextWriterEndElement(writer);      set_opened = false;    }    if (rt.lines[i].empty()) {      xmlTextWriterEndElement(writer);    }  }  xmlTextWriterEndDocument(writer);  xmlTextWriterFlush(writer);  g_file_set_contents("/home/joe/ot-parallel-passages.xml", (const gchar *)buffer->content, -1, NULL);  if (writer)    xmlFreeTextWriter(writer);  if (buffer)    xmlBufferFree(buffer);}

/** * xml_writer_clear: * @writer: A #XmlWriter * * Clears the current state of the #XmlWriter. This allows you * to reuse the same writer for multiple files or buffers. */voidxml_writer_clear (XmlWriter *writer){  XmlWriterPrivate *priv;    g_return_if_fail (XML_IS_WRITER (writer));    priv = writer->priv;  if (priv->writer)    xmlFreeTextWriter (priv->writer);      priv->writer = NULL;}

int save_gpx(const char *fname,GList *save_list){  time_t t=time(NULL);  struct tm tm;  GList *l;  xmlTextWriterPtr writer;  writer=xmlNewTextWriterFilename(fname,0);  if (!writer)    return 0;  xmlTextWriterStartDocument(writer,NULL,"UTF-8",NULL);  xmlTextWriterStartElement(writer,(xmlChar *)"gpx");  xmlTextWriterWriteAttribute(writer,(xmlChar *)"version",(xmlChar *)"1.0");  xmlTextWriterWriteAttribute(writer,(xmlChar *)"creator",(xmlChar *)PACKAGE " " VERSION);  xmlTextWriterWriteAttribute(writer,(xmlChar *)"xmlns:xsi",(xmlChar *)"http://www.w3.org/2001/XMLSchema-instance");  xmlTextWriterWriteAttribute(writer,(xmlChar *)"xmlns",			      (xmlChar *)"http://www.topografix.com/GPX/1/0");  xmlTextWriterWriteAttribute(writer,(xmlChar *)"xsi:schemaLocation",(xmlChar *)"http://www.topografix.com/GPX/1/0 http://www.topografix.com/GPX/1/0/gpx.xsd");  tm=*gmtime(&t);  xmlTextWriterWriteFormatElement(writer,(xmlChar *)"time","%04d-%02d-%02dT%02d:%02d:%02d",			    tm.tm_year+1900,tm.tm_mon+1,tm.tm_mday,			    tm.tm_hour,tm.tm_min,tm.tm_sec);  xmlTextWriterStartElement(writer,(xmlChar *)"trk");  xmlTextWriterStartElement(writer,(xmlChar *)"trkseg");  for(l=g_list_first(save_list);l;l=g_list_next(l)) {    struct t_punkt32 *p=(struct t_punkt32 *)l->data;    xmlTextWriterStartElement(writer,(xmlChar *)"trkpt");    xmlTextWriterWriteFormatAttribute(writer,(xmlChar *)"lat","%f",				      p->latt);    xmlTextWriterWriteFormatAttribute(writer,(xmlChar *)"lon","%f",				      p->longg);    if (p->time) {      t=p->time;      tm=*gmtime(&t);      xmlTextWriterWriteFormatElement(writer,(xmlChar*)"time",				"%04d-%02d-%02dT%02d:%02d:%02d",				tm.tm_year+1900,tm.tm_mon+1,tm.tm_mday,				tm.tm_hour,tm.tm_min,tm.tm_sec);    }    if (p->speed>0)      xmlTextWriterWriteFormatElement(writer,(xmlChar *)"speed","%f",p->speed*1.852/3.6);    xmlTextWriterEndElement(writer); /* /trkpt */      }  xmlTextWriterEndElement(writer); /*trkseg */  xmlTextWriterEndElement(writer); /* trk */  xmlTextWriterEndElement(writer); /* gpx */  xmlTextWriterEndDocument(writer);  xmlFreeTextWriter(writer);  return 1;}

static int _exml_write(EXML *xml, xmlTextWriterPtr writer){	xmlTextWriterSetIndent( writer, 1 );	xmlTextWriterSetIndentString( writer, (xmlChar *) "/t" );	xmlTextWriterStartDocument( writer, NULL, NULL, NULL );	/* as of now, we do not write a DTD.  This will be in effect with a new	 * set of functions designed to manipulate the DTD, as well as added	 * capability for reading DTDs from orthogonal read sources */	_exml_write_element(xml->top, writer);	xmlTextWriterEndDocument( writer );	xmlFreeTextWriter( writer );	return TRUE;}

/**Writes the report footer to Xml file..Write the xml end doc info..Release the writer pointer from the buffer.Writes the buffer content to xml file.Frees the xml buffer.@internalComponent@released*/void XmlWriter::EndReport(void){	xmlTextWriterEndElement(iXmlTextWriter);	xmlTextWriterEndElement(iXmlTextWriter);	xmlTextWriterEndDocument(iXmlTextWriter);	xmlFreeTextWriter(iXmlTextWriter);		iXmlFile.clear(); 	iXmlFile.write((const char *)iXmlBufPtr->content,iXmlBufPtr->use);	 	if(iXmlFile.fail()){		xmlBufferFree(iXmlBufPtr);		throw ExceptionReporter(NODISKSPACE, (char*)iXmlFileName.c_str()); 	}	xmlBufferFree(iXmlBufPtr);}

void c_XMLWriter::sweep() {  if (m_ptr) {    assert(m_ptr != xmlTextWriterPtr(-1));    xmlFreeTextWriter(m_ptr);    if (debug) {      m_ptr = xmlTextWriterPtr(-1);    }  }  if (m_output) {    assert(m_output != xmlBufferPtr(-1));    xmlBufferFree(m_output);    if (debug) {      m_output = xmlBufferPtr(-1);    }  }}

xml_writer::~xml_writer() throw() {  // close and flush the xml writer object. note - if this fails then  // there isn't much we can do, as this object is going to be deleted  // anyway.  try {    xmlTextWriterEndDocument(pimpl->writer);  } catch (...) {    // don't do anything here or we risk FUBARing the entire program.    // it might not be possible to end the document because the output    // stream went away. if so, then there is nothing to do but try    // and reclaim the extra memory.  }  xmlFreeTextWriter(pimpl->writer);  // finally, delete the PIMPL object  delete pimpl;}