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

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

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

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

void TrackerConfig::dump() const{    string s;    xmlBufferPtr pBuffer = xmlBufferCreate();    xmlNodeDump(pBuffer, m_Doc, m_pRoot, 0, 0);    cerr << xmlBufferContent(pBuffer) << endl;}

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

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 *generate_xml(NFE *nfe, EVP_PKEY *key, X509 *cert) {	int rc;	xmlTextWriterPtr writer;	xmlDocPtr doc;	xmlBufferPtr buf = xmlBufferCreate();	writer = xmlNewTextWriterDoc(&doc, 0);	if (writer == NULL)		return NULL;	xmlTextWriterStartDocument(writer, NULL, "UTF-8", NULL);	rc = gen_inf_nfe(writer, nfe);	if (rc < 0)		return NULL;	xmlTextWriterEndDocument(writer);	char *URI = malloc(sizeof(char) * (strlen(nfe->idnfe->chave) +		strlen(ID_PREFIX) + 2));	strcpy(URI, "#");	strcat(URI, ID_PREFIX);	strcat(URI, nfe->idnfe->chave);	rc = sign_xml(doc, key, cert, URI);	if(rc)		return NULL;	xmlNodeDump(buf, NULL, xmlDocGetRootElement(doc), 0, 0);	nfe->xml = strdup((char*)buf->content);	return (char*)buf->content;}

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

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

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

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

/** * レスをIDで抽出してファイルから
C++ xmlNodeGetContent函数代码示例
C++ xmlNewTextChild函数代码示例