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

/* wrapper for stats_event, this takes a charset to convert from */void stats_event_conv(const char *mount, const char *name, const char *value, const char *charset){    const char *metadata = value;    xmlBufferPtr conv = xmlBufferCreate ();    if (charset && value)    {        xmlCharEncodingHandlerPtr handle = xmlFindCharEncodingHandler (charset);        if (handle)        {            xmlBufferPtr raw = xmlBufferCreate ();            xmlBufferAdd (raw, (const xmlChar *)value, strlen (value));            if (xmlCharEncInFunc (handle, conv, raw) > 0)                metadata = (char *)xmlBufferContent (conv);            xmlBufferFree (raw);            xmlCharEncCloseFunc (handle);        }        else            WARN1 ("No charset found for /"%s/"", charset);    }    stats_event (mount, name, metadata);    xmlBufferFree (conv);}

intsrd_printElementSet (xmlDocPtr doc, xmlNodeSet *nodeSet, char **printBuffPtr, int printBuffSize){    xmlNode *cur_node = NULL;    int n, i;    xmlChar *value;    int offset = 0;    xmlBuffer *buff;    int size = printBuffSize;    char *newSpace;    for (i=0; i < nodeSet->nodeNr; i++) {    	cur_node = nodeSet->nodeTab[i];        if (cur_node->type == XML_ELEMENT_NODE) {           buff = xmlBufferCreate ();           xmlNodeDump (buff, doc,cur_node, 0, 1 );           if (size < (offset + strlen((char *)buff->content) + 1)){        	   size = offset + strlen((char *)buff->content) + 1;        	   newSpace = (char *)realloc (*printBuffPtr, size);        	   if (newSpace){        		   *printBuffPtr = newSpace;        	   } else {        		   // unable to allocate space        		   xmlBufferFree (buff);        		   return -1;        	   }           }           n = sprintf (*printBuffPtr+offset, "%s", buff->content);           offset = offset + n;           xmlBufferFree (buff);        }    }    return (offset);}

char *epp_getSubtree(void *pool,		epp_command_data *cdata,		const char *xpath_expr,		int position){	char	*subtree;	xmlBufferPtr	 buf;	xmlDocPtr	 doc;	xmlNodePtr	 node;	xmlXPathObjectPtr	 xpath_obj;	xmlXPathContextPtr	 xpath_ctx;	doc = (xmlDocPtr) cdata->parsed_doc;	xpath_ctx = (xmlXPathContextPtr) cdata->xpath_ctx;	xpath_obj = xmlXPathEvalExpression(BAD_CAST xpath_expr, xpath_ctx);	if (xpath_obj == NULL)		return NULL;	/* correct position for non-list elements */	if (position == 0) position++;	if (xmlXPathNodeSetGetLength(xpath_obj->nodesetval) < position) {		xmlXPathFreeObject(xpath_obj);		/* return empty string if the node is not there */		return epp_strdup(pool, "");	}	/*	 * Get content of problematic tag. It's not so easy task. We have	 * to declare namespaces defined higher in the tree which are relevant	 * to the part of document being dumped. Fortunatelly there is a	 * function from libxml library doing exactly that (xmlreconsiliatens).	 */	buf = xmlBufferCreate();	if (buf == NULL)		return NULL;	node = xmlXPathNodeSetItem(xpath_obj->nodesetval, position - 1);	if (node->ns != NULL) {		xmlNsPtr	 nsdef;		nsdef = xmlSearchNs(doc, node, node->ns->prefix);		if (nsdef != NULL)			xmlNewNs(node, nsdef->href, nsdef->prefix);	}	if (xmlNodeDump(buf, doc, node, 0, 0) < 0)	{		xmlXPathFreeObject(xpath_obj);		xmlBufferFree(buf);		return NULL;	}	subtree = epp_strdup(pool, (char *) buf->content);	xmlXPathFreeObject(xpath_obj);	xmlBufferFree(buf);	return subtree;}

static intxsltNumberFormatGetValue(xmlXPathContextPtr context,			 xmlNodePtr node,			 xmlChar *value,			 double *number){    int amount = 0;    xmlBufferPtr pattern;    xmlXPathObjectPtr obj;        pattern = xmlBufferCreate();    if (pattern != NULL) {	xmlBufferCCat(pattern, "number(");	xmlBufferCat(pattern, value);	xmlBufferCCat(pattern, ")");	context->node = node;	obj = xmlXPathEvalExpression(xmlBufferContent(pattern),				     context);	if (obj != NULL) {	    *number = obj->floatval;	    amount++;	    xmlXPathFreeObject(obj);	}	xmlBufferFree(pattern);    }    return amount;}

boolXml::saveToBuffer(XmlNode *curNode, std::string *buf) const{    if (NULL == curNode) {        fprintf(stderr, "[ERROR] In Xml::saveToBuffer, curNode == NULL/n");        return false;    }    if (NULL == buf) {        fprintf(stderr, "[ERROR] In Xml::saveToBuffer, buf == NULL/n");        return false;    }    xmlBuffer *xmlBuf = xmlBufferCreate();    if (NULL == xmlBuf) {        fprintf(stderr, "[ERROR] In Xml::saveToBuffer, "                "xmlBufferCreate() error/n");        return false;    }    int bytes = xmlNodeDump(xmlBuf, _doc, curNode,                            XML_INDENT_LEVEL, XML_FORMAT_ALLOWED);    if (bytes < 0) {        fprintf(stderr, "[ERROR] In Xml::saveToBuffer, xmlNodeDump() error/n");        return false;    }    *buf = (const char *)(xmlBuf->content);    xmlBufferFree(xmlBuf);    xmlBuf = NULL;    return true;}

/*********************************************** *  生成XML的字符串                            * *  成功返回XML的字符串                        * *  失败则返回NULL                             * *  doc用完已自动清空                          * ***********************************************/byte * generateXmlBuffer(xmlDocPtr doc){	static byte szBuf[2048];	byte * buffer;	xmlBufferPtr buf = NULL;    	xmlSaveCtxtPtr ctxt = NULL;	LIBXML_TEST_VERSION;	if(doc == NULL) {		ErrorLog(ERROR, "doc is null");		printf("doc is null");		return NULL;	}	buf = xmlBufferCreate();    	ctxt = xmlSaveToBuffer(buf, "UTF-8", 1);    	xmlSaveDoc(ctxt, doc);    	xmlSaveClose(ctxt);		memset(szBuf, 0x00, sizeof(szBuf));	buffer = u2g(buf->content);	sprintf(szBuf, "%s",buffer );		buf->content = NULL;    	xmlBufferFree(buf);    	xmlFreeDoc(doc);    	xmlCleanupParser();		free(buffer);	return szBuf;}

string as_string(xmlNodePtr node) {    xmlBufferPtr buf = xmlBufferCreate();    xmlNodeDump(buf,node->doc,node,0,1);    string result((char*)buf->content);    xmlBufferFree(buf);    return result;}

char* fileinfo_get(char* path) {    FILE* file;    xmlBufferPtr buf;    xmlTextWriterPtr writer;    char* ret;    int wordCount;    file  = fopen(path, "r");    wordCount = countWords(file);    fclose(file);    buf = xmlBufferCreate();    writer = xmlNewTextWriterMemory(buf, 0);    xmlTextWriterStartDocument(writer, NULL, XML_E, NULL);    xmlTextWriterStartElement(writer, BAD_CAST "fileInfo");    xmlTextWriterWriteFormatElement(writer, BAD_CAST "wordCount", "%d", wordCount);    xmlTextWriterEndElement(writer);    xmlTextWriterEndDocument(writer);    ret = malloc(buf->size);    strcpy(ret,(char*)buf->content);    xmlBufferFree(buf);    return ret;}

char * list_to_xml1(list_t list) {    xmlDoc * doc = NULL;	xmlNode * rootNode = NULL;	xmlNode * studentNode = NULL;	xmlNode * groupNode = NULL;	char strBuf[100];	char * text = malloc(sizeof (char) * 10000);	doc = xmlNewDoc("1.0");	rootNode = xmlNewNode(NULL, "directors");	for (int i = 0;i < list_size(list); i++)	{		if (list_get(list, i) == NULL)			continue;		puts(((struct admin_s *)list_get(list, i))->name);		xmlDocSetRootElement(doc, rootNode);		studentNode = xmlNewChild(rootNode, NULL, "director", NULL);		xmlNewChild(studentNode, NULL, "name", ((struct admin_s *)list_get(list, i))->name);		xmlNewChild(studentNode, NULL, "surname", ((struct admin_s *)list_get(list, i))->surname);		sprintf(strBuf, "%i", ((struct admin_s *)list_get(list, i))->buget);		xmlNewChild(studentNode, NULL, "buget", strBuf);		sprintf(strBuf, "%llf", ((struct admin_s *)list_get(list, i))->years);		xmlNewChild(studentNode, NULL, "years", strBuf);		xmlNewChild(studentNode, NULL, "birthdate", ((struct admin_s *)list_get(list, i))->birthdate);	}	xmlBuffer * bufferPtr = xmlBufferCreate();		xmlNodeDump(bufferPtr, NULL, (xmlNode *)doc, 0, 1);		printf("%s", (const char *)bufferPtr->content);    		strcpy(text, (const char *)bufferPtr->content);		xmlBufferFree(bufferPtr);      xmlFreeDoc(doc);	xmlCleanupParser();	return text;}

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

/** * Serialises an xmlNode to a string * * @param log   Log context * @param node Input XML node to be serialised * * @return Returns a pointer to a new buffer containing the serialised data.  This buffer must be freed *         after usage */char *xmlNodeToString(LogContext *log, xmlNode *node) {	xmlBuffer *buf = NULL;	xmlSaveCtxt *serctx = NULL;	char *ret = NULL;	if( node == NULL ) {		writelog(log, LOG_ALERT, "xmlNodeToString: Input data is NULL");		return NULL;	}	buf = xmlBufferCreate();	assert( buf != NULL );	serctx = xmlSaveToBuffer(buf, "UTF-8", XML_SAVE_NO_EMPTY|XML_SAVE_NO_DECL);	assert( serctx != NULL );	if( xmlSaveTree(serctx, node) < 0 ) {		writelog(log, LOG_ALERT, "xmlNodeToString: Failed to serialise xmlNode");		return NULL;	}	xmlSaveClose(serctx);	ret = strdup_nullsafe((char *) xmlBufferContent(buf));	xmlBufferFree(buf);	return ret;}

VALUE search(VALUE self, VALUE xpathExpr){  VALUE results = rb_ary_new();  xmlDocPtr doc;  xmlXPathObjectPtr xpathObj;  xmlNodeSetPtr nodes;  xmlNodePtr cur;  xmlBufferPtr nodeBuffer;  int size, i;  Data_Get_Struct(self, xmlDoc, doc);  xpathObj = eval_and_search(doc, StringValueCStr(xpathExpr));  if (xpathObj == NULL) { return Qnil; }  nodes = xpathObj->nodesetval;  size = (nodes) ? nodes->nodeNr : 0;  for (i = 0; i < size; ++i) {    nodeBuffer = xmlBufferCreate();    xmlNodeDump(nodeBuffer, doc, nodes->nodeTab[i], 0, 1);    rb_ary_push(results, rb_str_new2(nodeBuffer->content));    xmlBufferFree(nodeBuffer);  }  xmlXPathFreeObject(xpathObj);  return results;}

  void  closeFile()  {    mXPath.clear();    // This section writes to file    std::ofstream fileStream;    if(!mStream) {      fileStream.open(mXMLFilePath.c_str());      mStream = &fileStream;    }    xmlBufferPtr buffer = xmlBufferCreate();    xmlOutputBuffer * outputBuffer = xmlOutputBufferCreateBuffer(buffer,                                                                 NULL);    xmlSaveFormatFileTo(outputBuffer,                        mXMLDocument,                        "utf-8",                        1);    *mStream << buffer->content;    xmlBufferFree(buffer);        if(fileStream.is_open()) {      fileStream.close();      mStream = NULL;    }        xmlFreeDoc(mXMLDocument);    xmlCleanupParser();    if(mHeavyDataWriter->getMode() == XdmfHeavyDataWriter::Default) {      mHeavyDataWriter->closeFile();    }  };

/**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);}

char *teacher_to_message(teacher_t *self, int id){    if(!self)        return NULL;    char buff[MSG_LENGTH];    xmlDoc * doc = NULL;	xmlNode * rootNode = NULL;	xmlNode * teacherNode = NULL;	xmlNode * cathedraNode = NULL;    doc = xmlNewDoc("1.0");	rootNode = xmlNewNode(NULL, "teachers");	xmlDocSetRootElement(doc, rootNode);	char strBuf[100];	teacherNode = xmlNewChild(rootNode, NULL, "teacher", NULL);	sprintf(strBuf, "%i", id);	xmlNewChild(teacherNode, NULL, "id", strBuf);	xmlNewChild(teacherNode, NULL, "firstName", self->name);	xmlNewChild(teacherNode, NULL, "lastName", self->surname);	xmlNewChild(teacherNode, NULL, "pensionDate", self->date);	sprintf(strBuf, "%i", self->hours);	xmlNewChild(teacherNode, NULL, "hours", strBuf);	sprintf(strBuf, "%f", self->rating);	xmlNewChild(teacherNode, NULL, "rating", strBuf);	cathedraNode = xmlNewChild(teacherNode, NULL, "cathedra", NULL);	xmlNewProp(cathedraNode, "name", self->cathedra->name);	xmlNewChild(cathedraNode, NULL, "speciality", self->cathedra->speciality);	xmlNewChild(cathedraNode, NULL, "group", self->cathedra->groups[0]);	xmlNewChild(cathedraNode, NULL, "group", self->cathedra->groups[1]);	xmlBuffer * bufferPtr = xmlBufferCreate();	xmlNodeDump(bufferPtr, NULL, (xmlNode *)doc, 0, 1);	sprintf(buff, "%s", (const char*)bufferPtr->content);    xmlFreeDoc(doc);	xmlCleanupParser();	xmlBufferFree(bufferPtr);    return buff;}

char * info_to_xml(char * name, char * group, char * var){	xmlDoc * doc = NULL;	xmlNode * rootNode = NULL;	doc = xmlNewDoc("1.0");	rootNode = xmlNewNode(NULL, "persons");	//FILE * file = fopen("newBase.xml", "w");	char * text = malloc(sizeof(char) * 1000);	for (int i = 0; i < 1000; i++)	{		text[i] = '/0';	}	xmlDocSetRootElement(doc, rootNode);	xmlNewChild(rootNode, NULL, "student", name);	xmlNewChild(rootNode, NULL, "group", group);	xmlNewChild(rootNode, NULL, "variant", var);	xmlBuffer * bufferPtr = xmlBufferCreate();	xmlNodeDump(bufferPtr, NULL, (xmlNode *)doc, 0, 1);	strcat(text, bufferPtr->content);	xmlBufferFree(bufferPtr);	xmlFreeDoc(doc);	xmlCleanupParser();	puts(text);	return text;}

int lpc2xml_convert_string(lpc2xml_context* context, char **content) {	int ret = -1;	xmlBufferPtr buffer = xmlBufferCreate();	xmlSaveCtxtPtr save_ctx;	lpc2xml_context_clear_logs(context);	xmlSetGenericErrorFunc(context, lpc2xml_genericxml_error);	save_ctx = xmlSaveToBuffer(buffer, "UTF-8", XML_SAVE_FORMAT);	if(save_ctx != NULL) {		ret = internal_convert_lpc2xml(context);		if(ret == 0) {			ret = xmlSaveDoc(save_ctx, context->doc);			if(ret != 0) {				lpc2xml_log(context, LPC2XML_ERROR, "Can't save document");				lpc2xml_log(context, LPC2XML_ERROR, "%s", context->errorBuffer);			}		}		xmlSaveClose(save_ctx);	} else {		lpc2xml_log(context, LPC2XML_ERROR, "Can't initialize internal buffer");		lpc2xml_log(context, LPC2XML_ERROR, "%s", context->errorBuffer);	}	if(ret == 0) {#if LIBXML_VERSION >= 20800		*content = (char *)xmlBufferDetach(buffer);#else		*content = strdup((const char *)xmlBufferContent(buffer));#endif	}	xmlBufferFree(buffer);	return ret;}

const std::string queryResult::to_xml(){	xmlDocPtr doc;	xmlNodePtr root;	int rc;	std::string returnValue;	doc = xmlNewDoc(BAD_CAST "1.0");	root = xmlNewNode(NULL, BAD_CAST "result");	std::stringstream temp;	temp << size();	xmlNewProp(root, BAD_CAST "count", BAD_CAST temp.str().c_str());	if(__code != 0) {		temp.str("");		temp << __code;		xmlNewProp(root, BAD_CAST "ocicode", BAD_CAST temp.str().c_str());	}	if(__info.length()) {		xmlNewProp(root, BAD_CAST "ociinfo", BAD_CAST __info.c_str());	}	xmlDocSetRootElement(doc, root);	for(int i=0; i<size(); ++i) {			xmlNodePtr branch = xmlNewChild(root, NULL, BAD_CAST "branch", NULL);				std::multimap<std::string, std::string>::iterator it, iend = at(i).end();			for(it=at(i).begin(); it!=iend; ++it) {						xmlNodePtr child = xmlNewChild(branch, NULL, BAD_CAST it->first.c_str(), BAD_CAST it->second.c_str());					}		}	xmlNodePtr bind = xmlNewChild(root, NULL, BAD_CAST "bind", NULL);	std::map<std::string, std::pair<std::string, bool> >::iterator j, jend = __bindouts.end();	for(j = __bindouts.begin(); j != jend; ++j) {		if(j->second.second == true)			continue;		xmlNodePtr child = xmlNewChild(bind, NULL, BAD_CAST j->first.c_str(), BAD_CAST j->second.first.c_str());	}	xmlBufferPtr buf = xmlBufferCreate();	xmlSaveCtxtPtr sav = xmlSaveToBuffer(buf, "UTF-8", XML_SAVE_FORMAT | XML_SAVE_NO_EMPTY);	xmlSaveDoc(sav, doc);	xmlSaveClose(sav);	returnValue = (char*)buf->content;	xmlBufferFree(buf);	xmlFreeDoc(doc);	return returnValue;}

bool CXmlTree::WriteXmlFileToString(cvs::string& string) const{	xmlBufferPtr buffer = xmlBufferCreate();	if(!buffer)		return false;	xmlSaveCtxtPtr save = xmlSaveToBuffer(buffer, NULL, 0);	if(!save)	{		xmlBufferFree(buffer);		return false;	}	xmlSaveDoc(save, m_doc);	xmlSaveFlush(save);	xmlSaveClose(save);	string = (const char*)xmlBufferContent(buffer);	xmlBufferFree(buffer);	return true;}

const std::string XMLElement::dump(bool indent) const{    xmlBufferPtr buffer = xmlBufferCreate();    xmlNodeDump(buffer, doc.getRealDocument(), node, 0, indent ? 1 : 0);    std::string str = std::string((const char *)buffer->content);    xmlBufferFree(buffer);    return str;}

	/*}}}*/};static int	psize = sizeof (parseable) / sizeof (parseable[0]);tag_t *tag_alloc (void) /*{{{*/{	tag_t	*t;		if (t = (tag_t *) malloc (sizeof (tag_t))) {		t -> name = xmlBufferCreate ();		t -> cname = NULL;		t -> hash = 0;		t -> type = NULL;		t -> topt = NULL;		t -> value = xmlBufferCreate ();		t -> parm = NULL;		t -> used = false;		t -> next = NULL;		if ((! t -> name) || (! t -> value))			t = tag_free (t);	}	return t;}/*}}}*/tag_t *tag_free (tag_t *t) /*{{{*/{	if (t) {		if (t -> name)			xmlBufferFree (t -> name);		if (t -> cname)			free (t -> cname);		if (t -> type)			free (t -> type);		if (t -> value)			xmlBufferFree (t -> value);		if (t -> parm)			var_free_all (t -> parm);		free (t);	}	return NULL;}/*}}}*/

//!//! Places raw XML result of an xpath query into buf. The query must return//! only one element.//!//! @param[in] xml_path a string containing the path to the XML file to parse//! @param[in] xpath a string contianing the XPATH expression to evaluate//! @param[out] buf for the XML string//! @param[in] buf_len size of the buf//!//! @return EUCA_OK or EUCA_ERROR//!int get_xpath_xml(const char *xml_path, const char *xpath, char *buf, int buf_len){    int ret = EUCA_ERROR;    xmlDocPtr doc = NULL;    xmlXPathContextPtr context = NULL;    xmlXPathObjectPtr result = NULL;    xmlNodeSetPtr nodeset = NULL;    INIT();    pthread_mutex_lock(&xml_mutex);    {        if ((doc = xmlParseFile(xml_path)) != NULL) {            if ((context = xmlXPathNewContext(doc)) != NULL) {                if ((result = xmlXPathEvalExpression(((const xmlChar *)xpath), context)) != NULL) {                    if (!xmlXPathNodeSetIsEmpty(result->nodesetval)) {                        nodeset = result->nodesetval;                        if (nodeset->nodeNr > 1) {                            fprintf(stderr, "multiple matches for '%s' in '%s'/n", xpath, xml_path);                        } else {                            xmlNodePtr node = nodeset->nodeTab[0]->xmlChildrenNode;                            xmlBufferPtr xbuf = xmlBufferCreate();                            if (xbuf) {                                int len = xmlNodeDump(xbuf, doc, node, 0, 1);                                if (len < 0) {                                    fprintf(stderr, "failed to extract XML from %s/n", xpath);                                } else if (len > buf_len) {                                    fprintf(stderr, "insufficient buffer for %s/n", xpath);                                } else {                                    char *str = (char *)xmlBufferContent(xbuf);                                    euca_strncpy(buf, str, buf_len);                                    ret = EUCA_OK;                                }                                xmlBufferFree(xbuf);                            } else {                                fprintf(stderr, "failed to allocate XML buffer/n");                            }                        }                    }                    xmlXPathFreeObject(result);                } else {                    fprintf(stderr, "no results for '%s' in '%s'/n", xpath, xml_path);                }                xmlXPathFreeContext(context);            } else {                fprintf(stderr, "failed to set xpath '%s' context for '%s'/n", xpath, xml_path);            }            xmlFreeDoc(doc);        } else {            fprintf(stderr, "failed to parse XML in '%s'/n", xml_path);        }    }    pthread_mutex_unlock(&xml_mutex);    return ret;}

std::string XMLConfObj::toString(){    xmlIndentTreeOutput = 1;    xmlKeepBlanksDefault(0);    xmlBufferPtr xmlBufPtr = xmlBufferCreate();    xmlNodeDump(xmlBufPtr, documentTree, currentLevel, 0, 1);    std::string ret = std::string((char *)xmlBufPtr->content, xmlBufPtr->use);    xmlBufferFree(xmlBufPtr);    return ret;}

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

static voidbiji_lazy_serializer_finalize (GObject *object){  BijiLazySerializer *self = BIJI_LAZY_SERIALIZER (object);  BijiLazySerializerPrivate *priv = self->priv;  xmlBufferFree (priv->buf);  xmlFreeTextReader (priv->inner);  G_OBJECT_CLASS (biji_lazy_serializer_parent_class)->finalize (object);}