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

/** * xmlnode_to_pv: * @node: an xmlNode* object * @do_free: do we need to free the node after the conversion * * Return value: a newly allocated SV/PV or under. */static SV*xmlnode_to_pv(xmlNode *node, gboolean do_free){	xmlOutputBufferPtr buf;	SV *pestring = NULL;	if (node == NULL) {		return &PL_sv_undef;	}	buf = xmlAllocOutputBuffer(NULL);	if (buf == NULL) {		pestring = &PL_sv_undef;	} else {		xmlNodeDumpOutput(buf, NULL, node, 0, 1, NULL);		xmlOutputBufferFlush(buf);		if (buf->conv == NULL) {			pestring = newSVpv((char*)buf->buffer->content, 0);		} else {			pestring = newSVpv((char*)buf->conv->content, 0);		}		xmlOutputBufferClose(buf);	}	if (do_free) {		lasso_release_xml_node(node);	}	return pestring;}

QString XSL::process(const QString &my_xml){    QString my_xsl;    /* Petr Cimprich, Sablot developer:       &nbsp; is predefined in HTML but not in XML       ... use Unicode numerical entity instead: &#160;*/    my_xsl = quote_nbsp(my_xml);    xmlDocPtr doc = xmlParseMemory(my_xsl.toUtf8(), my_xsl.toUtf8().length());    if (doc == NULL){        string s;        s = static_cast<string>(my_xsl.toLocal8Bit());        log(L_WARN, "Parse XML error: %s", s.c_str());        return QString::null;    }    const char *params[1];    params[0] = NULL;    xmlDocPtr res = xsltApplyStylesheet(d->styleSheet, doc, params);    if (res == NULL){        log(L_WARN, "Apply stylesheet errror");        xmlFreeDoc(doc);        return QString::null;    }    xmlFreeDoc(doc);    xmlOutputBufferPtr buf = xmlAllocOutputBuffer(NULL);    xsltSaveResultTo(buf, res, d->styleSheet);    xmlFreeDoc(res);    QString result = QString::fromUtf8((char*)(buf->buffer->content));    xmlOutputBufferClose(buf);;    return result;}

extern "C" void DumpXMLString(xmlNodePtr node){    xmlOutputBufferPtr buf = xmlOutputBufferCreateFile(stdout, nullptr);    xmlNodeDumpOutput(buf, node->doc, node, 0, 0, nullptr);    xmlOutputBufferClose(buf);    fprintf(stdout, "/n/n");}

static gchar *update_apply_xslt (updateJobPtr job){	xsltStylesheetPtr	xslt = NULL;	xmlOutputBufferPtr	buf;	xmlDocPtr		srcDoc = NULL, resDoc = NULL;	gchar			*output = NULL;	g_assert (NULL != job->result);		do {		srcDoc = xml_parse (job->result->data, job->result->size, NULL);		if (!srcDoc) {			g_warning("fatal: parsing request result XML source failed (%s)!", job->request->filtercmd);			break;		}		/* load localization stylesheet */		xslt = xsltParseStylesheetFile (job->request->filtercmd);		if (!xslt) {			g_warning ("fatal: could not load filter stylesheet /"%s/"!", job->request->filtercmd);			break;		}		resDoc = xsltApplyStylesheet (xslt, srcDoc, NULL);		if (!resDoc) {			g_warning ("fatal: applying stylesheet /"%s/" failed!", job->request->filtercmd);			break;		}		buf = xmlAllocOutputBuffer (NULL);		if (-1 == xsltSaveResultTo (buf, resDoc, xslt)) {			g_warning ("fatal: retrieving result of filter stylesheet failed (%s)!", job->request->filtercmd);			break;		}		#ifdef LIBXML2_NEW_BUFFER		if (xmlOutputBufferGetSize (buf) > 0)			output = xmlCharStrdup (xmlOutputBufferGetContent (buf));#else		if (xmlBufferLength (buf->buffer) > 0)			output = xmlCharStrdup (xmlBufferContent (buf->buffer));#endif 		xmlOutputBufferClose (buf);	} while (FALSE);	if (srcDoc)		xmlFreeDoc (srcDoc);	if (resDoc)		xmlFreeDoc (resDoc);	if (xslt)		xsltFreeStylesheet (xslt);		return output;}

	xmlOutputBuffer_auto_ptr& operator=(const xmlOutputBuffer_auto_ptr& _Y) 		{if (this != &_Y)			{if (_Ptr != _Y.get())				{if (_Owns && _Ptr)					xmlOutputBufferClose(_Ptr);				_Owns = _Y._Owns; }			else if (_Y._Owns)				_Owns = true;			_Ptr = _Y.release(); }		return (*this); }

 void SaveResult(xmlDocPtr doc, xsltStylesheetPtr stylesheet, TBuffer& to) {     xmlOutputBufferPtr buf = xmlAllocOutputBuffer(NULL); // NULL means UTF8     xsltSaveResultTo(buf, doc, stylesheet);     if (buf->conv != NULL) {         to.Assign((const char*)buf->conv->content, buf->conv->use);     } else {         to.Assign((const char*)buf->buffer->content, buf->buffer->use);     }     xmlOutputBufferClose(buf); }

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 VALUE rxml_node_to_s(int argc, VALUE *argv, VALUE self){  VALUE result = Qnil;  VALUE options = Qnil;  xmlNodePtr xnode;  xmlCharEncodingHandlerPtr encodingHandler;  xmlOutputBufferPtr output;  int level = 0;  int indent = 1;  const char *xencoding = "UTF-8";  rb_scan_args(argc, argv, "01", &options);  if (!NIL_P(options))  {    VALUE rencoding, rindent, rlevel;    Check_Type(options, T_HASH);    rencoding = rb_hash_aref(options, ID2SYM(rb_intern("encoding")));    rindent = rb_hash_aref(options, ID2SYM(rb_intern("indent")));    rlevel = rb_hash_aref(options, ID2SYM(rb_intern("level")));    if (rindent == Qfalse)      indent = 0;    if (rlevel != Qnil)      level = NUM2INT(rlevel);    if (rencoding != Qnil)    {      xencoding = xmlGetCharEncodingName((xmlCharEncoding)NUM2INT(rencoding));      if (!xencoding)        rb_raise(rb_eArgError, "Unknown encoding value: %d", NUM2INT(rencoding));    }  }  encodingHandler = xmlFindCharEncodingHandler(xencoding);  output = xmlAllocOutputBuffer(encodingHandler);  xnode = rxml_get_xnode(self);  xmlNodeDumpOutput(output, xnode->doc, xnode, level, indent, xencoding);  xmlOutputBufferFlush(output);  if (output->conv)    result = rxml_new_cstr((const char*) output->conv->content, xencoding);  else    result = rxml_new_cstr((const char*) output->buffer->content, xencoding);  xmlOutputBufferClose(output);    return result;}

    std::string NSXmlCanonicalizator::Execute(const std::string& sXml, int mode, bool withComments)    {        xmlDocPtr xmlDoc = xmlParseMemory((char*)sXml.c_str(), (int)sXml.length());        CXmlBuffer bufferC14N;        xmlOutputBufferPtr _buffer = xmlOutputBufferCreateIO((xmlOutputWriteCallback)buffer_xmlBufferIOWrite,                                                             (xmlOutputCloseCallback)buffer_xmlBufferIOClose,                                                             &bufferC14N,                                                             NULL);        xmlC14NExecute(xmlDoc, buffer_xmlC14NIsVisibleCallback, NULL, mode, NULL, withComments ? 1 : 0, _buffer);        xmlOutputBufferClose(_buffer);        return bufferC14N.builder.GetData();    }

/* {{{ internalSubset	stringreadonly=yesURL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-Core-DocType-internalSubsetSince: DOM Level 2*/int dom_documenttype_internal_subset_read(dom_object *obj, zval *retval){	xmlDtdPtr dtdptr = (xmlDtdPtr) dom_object_get_node(obj);	xmlDtdPtr intsubset;	if (dtdptr == NULL) {		php_dom_throw_error(INVALID_STATE_ERR, 0);		return FAILURE;	}	if (dtdptr->doc != NULL && ((intsubset = xmlGetIntSubset(dtdptr->doc)) != NULL)) {		smart_str ret_buf = {0};		xmlNodePtr cur = intsubset->children;		while (cur != NULL) {			xmlOutputBuffer *buff = xmlAllocOutputBuffer(NULL);			if (buff != NULL) {				xmlNodeDumpOutput (buff, NULL, cur, 0, 0, NULL);				xmlOutputBufferFlush(buff);#ifdef LIBXML2_NEW_BUFFER				smart_str_appendl(&ret_buf, (const char *) xmlOutputBufferGetContent(buff), xmlOutputBufferGetSize(buff));#else				smart_str_appendl(&ret_buf, (char *) buff->buffer->content, buff->buffer->use);#endif				(void)xmlOutputBufferClose(buff);			}			cur = cur->next;		}		if (ret_buf.s) {			smart_str_0(&ret_buf);			ZVAL_NEW_STR(retval, ret_buf.s);			return SUCCESS;		}	}	ZVAL_NULL(retval);	return SUCCESS;}

static gbooleanews_client_autodiscover_data_free (gpointer user_data){  AutodiscoverData *data = user_data;  g_simple_async_result_complete_in_idle (data->res);  if (data->cancellable_id > 0)    {      g_cancellable_disconnect (data->cancellable, data->cancellable_id);      g_object_unref (data->cancellable);    }  /* soup_session_queue_message stole the references to data->msgs */  xmlOutputBufferClose (data->buf);  g_object_unref (data->res);  g_object_unref (data->session);  g_slice_free (AutodiscoverData, data);  return G_SOURCE_REMOVE;}

/** * htmlNodeDumpFileFormat: * @out:  the FILE pointer * @doc:  the document * @cur:  the current node * @encoding: the document encoding * @format:  should formatting spaces been added * * Dump an HTML node, recursive behaviour,children are printed too. * * TODO: if encoding == NULL try to save in the doc encoding * * returns: the number of byte written or -1 in case of failure. */inthtmlNodeDumpFileFormat(FILE *out, xmlDocPtr doc,	               xmlNodePtr cur, const char *encoding, int format) {    xmlOutputBufferPtr buf;    xmlCharEncodingHandlerPtr handler = NULL;    int ret;    xmlInitParser();    if (encoding != NULL) {	xmlCharEncoding enc;	enc = xmlParseCharEncoding(encoding);	if (enc != XML_CHAR_ENCODING_UTF8) {	    handler = xmlFindCharEncodingHandler(encoding);	    if (handler == NULL)		return(-1);	}    }    /*     * Fallback to HTML or ASCII when the encoding is unspecified     */    if (handler == NULL)	handler = xmlFindCharEncodingHandler("HTML");    if (handler == NULL)	handler = xmlFindCharEncodingHandler("ascii");    /*      * save the content to a temp buffer.     */    buf = xmlOutputBufferCreateFile(out, handler);    if (buf == NULL) return(0);    htmlNodeDumpFormatOutput(buf, doc, cur, encoding, format);    ret = xmlOutputBufferClose(buf);    return(ret);}

int xsltSaveResultToString(xmlChar **doc_txt_ptr, int * doc_txt_len, xmlDocPtr result, xsltStylesheetPtr style) {    xmlOutputBufferPtr buf;    *doc_txt_ptr = NULL;    *doc_txt_len = 0;    if (result->children == NULL)	return(0);	buf = xmlAllocOutputBuffer(NULL);    if (buf == NULL)		return(-1);    xsltSaveResultTo(buf, result, style);    if (buf->conv != NULL) {		*doc_txt_len = buf->conv->use;		*doc_txt_ptr = xmlStrndup(buf->conv->content, *doc_txt_len);    } else {		*doc_txt_len = buf->buffer->use;		*doc_txt_ptr = xmlStrndup(buf->buffer->content, *doc_txt_len);    }    (void)xmlOutputBufferClose(buf);    return 0;}

voidServer::sendResponse(Context *ctx, XmlDocSharedHelper doc) {    sendHeaders(ctx);    if (ctx->response()->suppressBody(ctx->request())) {        return;    }     xmlCharEncodingHandlerPtr encoder = NULL;    const std::string &encoding = ctx->documentWriter()->outputEncoding();    if (!encoding.empty() && 0 != strncasecmp(encoding.c_str(), "utf-8", sizeof("utf-8"))) {        encoder = xmlFindCharEncodingHandler(encoding.c_str());    }        xmlOutputBufferPtr buf = xmlOutputBufferCreateIO(writeFunc, closeFunc, ctx, encoder);    XmlUtils::throwUnless(NULL != buf);    try {        ctx->documentWriter()->write(ctx->response(), doc.get(), buf);    }    catch(const std::exception &e) {        xmlOutputBufferClose(buf);        throw e;    }}

static bool saveResultToString(xmlDocPtr resultDoc, xsltStylesheetPtr sheet, String& resultString){    xmlOutputBufferPtr outputBuf = xmlAllocOutputBuffer(0);    if (!outputBuf)        return false;    StringBuilder resultBuilder;    outputBuf->context = &resultBuilder;    outputBuf->writecallback = writeToStringBuilder;    int retval = xsltSaveResultTo(outputBuf, resultDoc, sheet);    xmlOutputBufferClose(outputBuf);    if (retval < 0)        return false;    // Workaround for <http://bugzilla.gnome.org/show_bug.cgi?id=495668>:    // libxslt appends an extra line feed to the result.    if (resultBuilder.length() > 0 && resultBuilder[resultBuilder.length() - 1] == '/n')        resultBuilder.resize(resultBuilder.length() - 1);    resultString = resultBuilder.toString();    return true;}

bool XmlWriter::Create(IOStream *output, XmlWriter **r) {  if (!LibXmlInitialized) {    Error(StringPieceFromLiteral("XmlWriter::Create(): call LibXmlInit first()"));    return false;  }  if (!output)    return false;  xmlOutputBufferPtr output_buffer = xmlOutputBufferCreateIO(_writeCallback, _closeCallback, output, NULL);  if (!output_buffer) {    Error(StringPieceFromLiteral("XmlWriter::Create(): xmlOutputBufferCreateIO fails"));    return false;  }  std::auto_ptr<XmlWriter> xml(new XmlWriter());  xml->libxml_stuff.reset(new LibXmlStuff());  /* NOTE: the xmlOutputBufferPtr parameter will be deallocated when the writer is closed (if the call succeed.) */  xml->libxml_stuff->writer = xmlNewTextWriter(output_buffer);  if (!xml->libxml_stuff->writer) {    xmlOutputBufferClose(output_buffer);    output_buffer = NULL;    Error(StringPieceFromLiteral("XmlWriter::Create(): xmlNewTextWriter fails"));    return false;  }  if (r) {    xmlTextWriterSetIndent(xml->libxml_stuff->writer, 1);    /*if (!xml->StartDocument(output)) {     cpcl::Error(cpcl::StringPieceFromLiteral("XmlWriter::Create(): xmlTextWriterStartDocument fails"));     return false;     }*/    *r = xml.release();  }  return true;}

/** * HTML整形 */const wxString ExtractBoardList::HtmlFormat(const wxString& html){     wxString val;     const wxCharBuffer& cb = html.utf8_str();     htmlDocPtr docPtr = htmlReadMemory(cb.data(), ::strlen(cb.data()), "", "utf-8", HTML_PARSE_RECOVER);     if (docPtr)     {	  // libxml2の***Ptrは何かの
C++ xmlParseChunk函数代码示例
C++ xmlNodeSetContent函数代码示例