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