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; }
bool Xml::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; }
int srd_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で抽出してファイルから読み取ってDOM形式にして送り返す * @param const wxString& rawHtml スレッドのHTML * @param const wxString& extractId 抽出対象のID * @return wxString 取得したレスの内容 */ wxString XrossBoardUtil::FindResponseByIndex(const wxString& rawHtml, const wxString& extractIndex) { // wxString::mb_str で変換するとWindowsの場合CP932が返ってくるので // まずはUTF-8のwxCharBufferに変換してやる const wxCharBuffer &cb = rawHtml.utf8_str(); const htmlDocPtr docPtr = htmlReadMemory(cb.data(), ::strlen(cb.data()), "", "utf-8", HTML_PARSE_RECOVER|HTML_PARSE_NOERROR|HTML_PARSE_NOWARNING); // HTMLのDOM形式にする wxString lumpOfHTML = HTML_HEADER_POPUP; if (docPtr) { const htmlNodePtr root = xmlDocGetRootElement(docPtr); const htmlNodePtr body = root->children->next; for (htmlNodePtr node = body->children; node != NULL; node = node->next) { if (node->type == XML_ELEMENT_NODE && xmlStrcasecmp(node->name, (const xmlChar*) "dd") == 0) { const htmlNodePtr dd = node->children; if (DDNodeHasTarget(dd, extractIndex)) { xmlBufferPtr buffer = xmlBufferCreate(); xmlNodeDump(buffer, docPtr, node->prev, 0, 1); xmlNodeDump(buffer, docPtr, node, 0, 1); lumpOfHTML += wxString::FromUTF8(reinterpret_cast<const char*>(buffer->content)); continue; } } } xmlFreeDoc(docPtr); xmlCleanupParser(); } // HTMLソースを加える lumpOfHTML += HTML_FOOTER; return lumpOfHTML; }
/*Write - writes xml tree of element to buffer output: data - is set to point to buffer containing xml data tlength - is set to length of xml data */ void CXMLElement::Write(char **data,int *tlength,Bool isformatted) { if (!isinited()) return; if (element->doc){ xmlBufferPtr buf; buf = xmlBufferCreate(); xmlNodeDump(buf, element->doc, element, 0, isformatted); *data = (char *)xmlStrdup(xmlBufferContent(buf)); *tlength = xmlBufferLength(buf); xmlBufferFree(buf); } }
/* * call-seq: * to_xml * * Returns this node as XML */ static VALUE to_xml(VALUE self) { xmlBufferPtr buf ; xmlNodePtr node ; VALUE xml ; Data_Get_Struct(self, xmlNode, node); buf = xmlBufferCreate() ; xmlNodeDump(buf, node->doc, node, 2, 1); xml = rb_str_new2((char*)buf->content); xmlBufferFree(buf); return xml ; }
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, "admins"); //FILE * file = fopen("newBase.xml", "w"); /*int id; char name[256]; char surname[256]; int birthdate; float rate; int creating_year; int followers;*/ 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, "admin", 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))->birthdate); xmlNewChild(studentNode, NULL, "birthdate", strBuf); sprintf(strBuf, "%llf", ((struct admin_s *)list_get(list, i))->rate); xmlNewChild(studentNode, NULL, "rate", strBuf); //groupNode = xmlNewChild(studentNode, NULL, "work", NULL); //xmlNewProp(groupNode, "name", ((struct person *)list_get(list, i))->work.name); sprintf(strBuf, "%i", ((struct admin_s *)list_get(list, i))->creating_year); xmlNewChild(studentNode, NULL, "creating_year",strBuf); sprintf(strBuf, "%i", ((struct admin_s *)list_get(list, i))->followers); xmlNewChild(studentNode, NULL, "followers", strBuf); puts("sdfgsfbsgf"); } xmlBuffer * bufferPtr = xmlBufferCreate(); xmlNodeDump(bufferPtr, NULL, (xmlNode *)doc, 0, 1); printf("%s", (const char *)bufferPtr->content); //fprintf(file, "%s", (const char *)bufferPtr->content); strcpy(text, (const char *)bufferPtr->content); xmlBufferFree(bufferPtr); //fclose(file); xmlFreeDoc(doc); xmlCleanupParser(); return text; }
const std::string XMLNodeList::dump() const { xmlBufferPtr buffer = xmlBufferCreate(); for (xmlNode * cur = parent->children; cur; cur = cur->next) { xmlNodeDump(buffer, doc.getRealDocument(), cur, 0, 1); xmlBufferAdd(buffer, (xmlChar *) "\n", (int)strlen("\n")); } std::string str = std::string((const char *)buffer->content); xmlBufferFree(buffer); return str; }
static gint plugin_ui_hook_construct (EPluginHook *hook, EPlugin *plugin, xmlNodePtr node) { EPluginUIHookPrivate *priv; priv = E_PLUGIN_UI_HOOK_GET_PRIVATE (hook); /* XXX The EPlugin should be a property of EPluginHookClass. * Then it could be passed directly to g_object_new() and * we wouldn't have to chain up here. */ /* Chain up to parent's construct() method. */ E_PLUGIN_HOOK_CLASS (parent_class)->construct (hook, plugin, node); for (node = node->children; node != NULL; node = node->next) { xmlNodePtr child; xmlBufferPtr buffer; const gchar *content; gchar *id; if (strcmp ((gchar *) node->name, "ui-manager") != 0) continue; id = e_plugin_xml_prop (node, "id"); if (id == NULL) { g_warning ("<ui-manager> requires 'id' property"); continue; } /* Extract the XML content below <ui-manager> */ buffer = xmlBufferCreate (); child = node->children; while (child != NULL && xmlNodeIsText (child)) child = child->next; if (child != NULL) xmlNodeDump (buffer, node->doc, child, 2, 1); content = (const gchar *) xmlBufferContent (buffer); g_hash_table_insert ( priv->ui_definitions, id, g_strdup (content)); xmlBufferFree (buffer); } return 0; }
/** * create preferences minimal buffer from NftPrefsNode - compared to * nft_prefs_node_to_buffer, this doesn't include any encapsulation or headers. * Just the bare information contained in the node. This should be used to * export single nodes, e.g. for copying them to a clipboard * * @param p NftPrefs context * @param n NftPrefsNode * @result string holding xml representation of object (use free() to deallocate) * @note s. @ref nft_prefs_node_to_file for description */ char *nft_prefs_node_to_buffer_minimal(NftPrefs *p, NftPrefsNode * n) { if(!n) NFT_LOG_NULL(NULL); /* result pointer (xml dump) */ char *dump = NULL; /* add prefs version to node */ if(!(_updater_node_add_version(p, n))) { NFT_LOG(L_ERROR, "failed to add version to node \"%s\"", nft_prefs_node_get_name(n)); return NULL; } /* create buffer */ xmlBufferPtr buf; if(!(buf = xmlBufferCreate())) { NFT_LOG(L_ERROR, "failed to xmlBufferCreate()"); return NULL; } /* dump node */ if(xmlNodeDump(buf, n->doc, n, 0, true) < 0) { NFT_LOG(L_ERROR, "xmlNodeDump() failed"); goto _pntb_exit; } /* allocate buffer */ size_t length = xmlBufferLength(buf); if(!(dump = malloc(length + 1))) { NFT_LOG_PERROR("malloc()"); goto _pntb_exit; } /* copy buffer */ strncpy(dump, (char *) xmlBufferContent(buf), length); dump[length] = '\0'; _pntb_exit: xmlBufferFree(buf); return dump; }
char *gen_lote_xml(LOTE *lote, 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 = xmlTextWriterStartElement(writer, BAD_CAST "enviNFe"); if (rc < 0) return NULL; rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "xmlns", BAD_CAST "http://www.portalfiscal.inf.br/nfe"); if (rc < 0) return NULL; rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "versao", BAD_CAST NFE_VERSAO); if (rc < 0) return NULL; rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "idLote", "%d", lote->id); if (rc < 0) return NULL; int indSinc = lote->qtd == 1? 1 : 0; rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "indSinc", "%d", indSinc); if (rc < 0) return NULL; int i; LOTE_ITEM *it = lote->nfes; for (i = 0; i < lote->qtd; i++){ char *xml; xml = generate_xml(it->nfe, key, cert); printf("%s\n", xml); rc = xmlTextWriterWriteRaw(writer, BAD_CAST xml); if (rc < 0) return NULL; it = it->next; } rc = xmlTextWriterEndElement(writer); if (rc < 0) return NULL; xmlTextWriterEndDocument(writer); xmlNodeDump(buf, NULL, xmlDocGetRootElement(doc), 0, 0); return (char*)buf->content; }
/* * call-seq: * node.dump -> (true|nil) * * Dump this node to stdout. */ VALUE ruby_xml_node_dump(VALUE self) { xmlNodePtr xnode; xmlBufferPtr buf; Data_Get_Struct(self, xmlNode, xnode); if (xnode->doc == NULL) return(Qnil); buf = xmlBufferCreate(); xmlNodeDump(buf, xnode->doc, xnode, 0, 1); xmlBufferDump(stdout, buf); xmlBufferFree(buf); return(Qtrue); }
// shows the XML dump of n in textview1 void show_in_textview1(const xmlNodePtr n) { xmlBufferPtr buf = xmlBufferCreate(); int ret2 = xmlNodeDump(buf, teidoc, n, 0, 1); g_assert(ret2 != -1); // XXX make textview1 global var to save lookups GtkTextView *textview1 = GTK_TEXT_VIEW(glade_xml_get_widget(my_glade_xml, "textview1")); GtkTextBuffer* b = gtk_text_view_get_buffer(textview1); gtk_text_buffer_set_text(b, (char *) xmlBufferContent(buf), -1); xmlBufferFree(buf); gtk_text_buffer_set_modified(b, FALSE); // XXX make sure notebook1 shows page 0 (XML view) }
void RL::Presentity::save (bool reload) { xmlBufferPtr buffer = xmlBufferCreate (); int result = xmlNodeDump (buffer, node->doc, node, 0, 0); if (result >= 0) { boost::shared_ptr<XCAP::Core> xcap = services.get<XCAP::Core> ("xcap-core"); xcap->write (path, "application/xcap-el+xml", (const char*)xmlBufferContent (buffer), boost::bind (&RL::Presentity::save_result, this, _1, reload)); } xmlBufferFree (buffer); }
string getXmlChildrenAsString(const xmlDocPtr xmlDoc, const xmlNodePtr& xmlNode) { string s; xmlBufferPtr pBuffer = xmlBufferCreate(); xmlNodeDump(pBuffer, xmlDoc, xmlNode, 0, 0); s = (const char *)xmlBufferContent(pBuffer); size_t StartPos = s.find('>')+1; size_t EndPos = s.rfind('<')-1; if (StartPos > EndPos) { s = ""; } else { s = s.substr(StartPos, EndPos-StartPos+1); } xmlBufferFree(pBuffer); return s; }
// Returns a structured annotation as raw text char* getNthStructuredAnnotationAsText(SBOLObject* obj, const int n) { if (n >= getNumStructuredAnnotations(obj)) { return NULL; } else { xmlBufferPtr buffer = xmlBufferCreate(); xmlKeepBlanksDefault(0); char *text = NULL; int size = xmlNodeDump(buffer, obj->uri->doc->xml_doc, getNthStructuredAnnotationAsXML(obj, n), 0, 0); if (buffer->content) { text = malloc(size + 1); // Allocate an extra byte for termination char strcpy(text, (char*)buffer->content); } xmlFree(buffer); return text; } }
/* convert an xmlNodePtr to a string */ guchar * gst_cmml_parser_node_to_string (GstCmmlParser * parser, xmlNodePtr node) { xmlBufferPtr xml_buffer; xmlDocPtr doc; guchar *str; if (parser) doc = parser->context->myDoc; else doc = NULL; xml_buffer = xmlBufferCreate (); xmlNodeDump (xml_buffer, doc, node, 0, 0); str = xmlStrndup (xml_buffer->content, xml_buffer->use); xmlBufferFree (xml_buffer); return str; }
char * list_to_xml_string(list_t list) { xmlDoc * doc = NULL; xmlNode * rootNode = NULL; xmlNode * studentNode = NULL; xmlNode * groupNode = NULL; char strBuf[100]; doc = xmlNewDoc("1.0"); rootNode = xmlNewNode(NULL, "persons"); FILE * file = fopen("newBase.xml", "w"); for (int i = 0;i < list_size(list); i++) { xmlDocSetRootElement(doc, rootNode); studentNode = xmlNewChild(rootNode, NULL, "person", NULL); xmlNewChild(studentNode, NULL, "name", ((struct person *)list_get(list, i))->name); xmlNewChild(studentNode, NULL, "surname", ((struct person *)list_get(list, i))->surname); xmlNewChild(studentNode, NULL, "birthdate", ((struct person *)list_get(list, i))->birthdate); sprintf(strBuf, "%i", ((struct person *)list_get(list, i))->age); xmlNewChild(studentNode, NULL, "age", strBuf); sprintf(strBuf, "%llf", ((struct person *)list_get(list, i))->experience_age); xmlNewChild(studentNode, NULL, "experience_age", strBuf); groupNode = xmlNewChild(studentNode, NULL, "work", NULL); //xmlNewProp(groupNode, "name", ((struct person *)list_get(list, i))->work.name); xmlNewChild(groupNode, NULL, "shop_name", ((struct person *)list_get(list, i))->work.shop_name); } xmlBuffer * bufferPtr = xmlBufferCreate(); xmlNodeDump(bufferPtr, NULL, (xmlNode *)doc, 0, 1); printf("%s", (const char *)bufferPtr->content); fprintf(file, "%s", (const char *)bufferPtr->content); fclose(file); xmlFreeDoc(doc); xmlCleanupParser(); char text[10000]; strcpy(text, bufferPtr->content); xmlBufferFree(bufferPtr); puts("\n\n\n"); puts(text); puts("\n\n\n"); return text; }
G_GNUC_INTERNAL char * gvir_config_xml_node_to_string(xmlNodePtr node) { xmlBufferPtr xmlbuf; char *xml; if (node == NULL) return NULL; xmlbuf = xmlBufferCreate(); if (xmlNodeDump(xmlbuf, node->doc, node, 0, 1) < 0) xml = NULL; else xml = g_strndup((gchar *)xmlBufferContent(xmlbuf), xmlBufferLength(xmlbuf)); xmlBufferFree(xmlbuf); return xml; }
int yaz_match_xsd_XML_n2(xmlNodePtr ptr, const char *elem, ODR o, char **val, int *len, int fixup_root) { xmlBufferPtr buf; int no_root_nodes = 0; if (!yaz_match_xsd_element(ptr, elem)) return 0; buf = xmlBufferCreate(); /* Copy each element nodes at top. In most cases there is only one root node.. At least one server http://www.theeuropeanlibrary.org/sru/sru.pl has multiple root nodes in recordData. */ for (ptr = ptr->children; ptr; ptr = ptr->next) { if (ptr->type == XML_ELEMENT_NODE) { /* copy node to get NS right (bug #740). */ xmlNode *tmp = xmlCopyNode(ptr, 1); xmlNodeDump(buf, tmp->doc, tmp, 0, 0); xmlFreeNode(tmp); no_root_nodes++; } } if (no_root_nodes != 1 && fixup_root) { /* does not appear to be an XML document. Make it so */ xmlBufferAddHead(buf, (const xmlChar *) "<yaz_record>", -1); xmlBufferAdd(buf, (const xmlChar *) "</yaz_record>", -1); } *val = odr_strdupn(o, (const char *) buf->content, buf->use); if (len) *len = buf->use; xmlBufferFree(buf); return 1; }