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

/** Add rectangle data to an attribute node. * @param attr The attribute node. * @param rect The value to set. */voiddata_add_rectangle(AttributeNode attr, const Rectangle *rect){  DataNode data_node;  gchar *buffer;  gchar rl_buf[G_ASCII_DTOSTR_BUF_SIZE];  gchar rr_buf[G_ASCII_DTOSTR_BUF_SIZE];  gchar rt_buf[G_ASCII_DTOSTR_BUF_SIZE];  gchar rb_buf[G_ASCII_DTOSTR_BUF_SIZE];  g_ascii_formatd(rl_buf, sizeof(rl_buf), "%g", rect->left);  g_ascii_formatd(rr_buf, sizeof(rr_buf), "%g", rect->right);  g_ascii_formatd(rt_buf, sizeof(rt_buf), "%g", rect->top);  g_ascii_formatd(rb_buf, sizeof(rb_buf), "%g", rect->bottom);  buffer = g_strconcat(rl_buf, ",", rt_buf, ";", rr_buf, ",", rb_buf, NULL);  data_node = xmlNewChild(attr, NULL, (const xmlChar *)"rectangle", NULL);  xmlSetProp(data_node, (const xmlChar *)"val", (xmlChar *)buffer);  g_free(buffer);}

xmlNodePtr msOWSCommonOperationsMetadataDomainType(int version, xmlNsPtr psNsOws, char *elname, char *name, char *values){  xmlNodePtr psRootNode = NULL;  xmlNodePtr psNode = NULL;  if (_validateNamespace(psNsOws) == MS_FAILURE)    psNsOws = xmlNewNs(psRootNode, BAD_CAST MS_OWSCOMMON_OWS_NAMESPACE_URI, BAD_CAST MS_OWSCOMMON_OWS_NAMESPACE_PREFIX);  psRootNode = xmlNewNode(psNsOws, BAD_CAST elname);  xmlNewProp(psRootNode, BAD_CAST "name", BAD_CAST name);  if (version == OWS_1_0_0) {    msLibXml2GenerateList(psRootNode, psNsOws, "Value", values, ',');  }  if (version == OWS_1_1_0 || version == OWS_2_0_0) {    psNode = xmlNewChild(psRootNode, psNsOws, BAD_CAST "AllowedValues", NULL);    msLibXml2GenerateList(psNode, psNsOws, "Value", values, ',');  }  return psRootNode;}

void add_systemp(xmlNodePtr node){  char buffer[24];  int systemp = 0;  if (HAVE_OPT(SYSTEMP_COMMAND)) {    char cmd[1024];    FILE *in;    sprintf(cmd, "%s > /tmp/.uw_sysstat.tmp", OPT_ARG(SYSTEMP_COMMAND));    uw_setproctitle("running %s", OPT_ARG(SYSTEMP_COMMAND));    system(cmd);    in = fopen("/tmp/.uw_sysstat.tmp", "r");    if (in) {      fscanf(in, "%d", &systemp);      fclose(in);    }    unlink("tmp/.uw_sysstat.tmp");  }  sprintf(buffer, "%d", systemp);  xmlNewChild(node, NULL, "systemp", buffer);}

bool DomTree::write(const std::string& file, bool indent) {	xmlDocPtr doc;	xmlNodePtr cur;	//xmlAttrPtr attr;		doc = xmlNewDoc((const xmlChar *)version.c_str());	doc->children = xmlNewDocNode(doc, NULL,(const xmlChar *)name.c_str(), NULL);		for(unsigned int i = 0; i < attributes.size() ; i++) {		xmlSetProp(doc->children,(const xmlChar *)attributes[i]->getName().c_str(),(const xmlChar *)attributes[i]->getValue().c_str());	}		for(unsigned int i = 0; i < elements.size() ; i++) {		cur = xmlNewChild(doc->children,NULL,(const xmlChar *)elements[i]->getName().c_str(),(xmlChar *)elements[i]->getValue().c_str());		if(elements[i]->getAttributes().size() > 0) {			for(unsigned int a = 0; a < elements[i]->getAttributes().size() ; a++) {				xmlSetProp(cur,(const xmlChar *)elements[i]->getAttributes()[a]->getName().c_str(),(const xmlChar *)elements[i]->getAttributes()[a]->getValue().c_str());			}		}		if ( elements[i]->getChildren().size() > 0 ) {				for(unsigned int b = 0; b < elements[i]->getChildren().size() ; b++) {				dumpXmlChild(cur,elements[i]->getChildren()[b]);			}		}	}		if((xmlSaveFormatFile((const char *)file.c_str(),doc,indent)) < 1) {				std::cout << "Error writing to file" << std::endl;				xmlFreeDoc(doc);		xmlCleanupParser();		return(false);	}			xmlFreeDoc(doc);	xmlCleanupParser();	return(true);}	

/** * Add a directory to the HTML tree for saving. * * /param  directory  hotlist directory to add * /param  node       node to add ul to * /return  true on success, false on memory exhaustion */static bool tree_url_save_directory(struct node *directory, xmlNode *node){	struct node *child;	xmlNode *ul, *h4;	const char *text;	ul = xmlNewChild(node, NULL, (const xmlChar *)"ul", NULL);	if (ul == NULL)		return false;	if (tree_node_is_default(directory) == true)		xmlSetProp(ul, (const xmlChar *) "id",				(const xmlChar *) "default");	for (child = tree_node_get_child(directory); child;	     child = tree_node_get_next(child)) {		if (!tree_node_is_folder(child)) {			/* entry */			if (!tree_url_save_entry(child, ul))				return false;		} else {			/* directory */			/* invalid HTML */			text = tree_url_node_get_title(child);			if (text == NULL)				return false;			h4 = xmlNewTextChild(ul, NULL,					     (const xmlChar *) "h4",					     (const xmlChar *) text);			if (h4 == NULL)				return false;			if (!tree_url_save_directory(child, ul))				return false;		}	}	return true;}

static void_arc(DiaRenderer *self, 	 Point *center,	 real width, real height,	 real angle1, real angle2,	 Color *color,	 gboolean fill){  DrsRenderer *renderer = DRS_RENDERER (self);  xmlNodePtr node;    node = xmlNewChild(renderer->root, NULL, (const xmlChar *)(fill ? "fill-arc" : "draw-arc"), NULL);  _node_set_point (node, "center", center);  _node_set_real (node, "width", width);  _node_set_real (node, "height", height);  _node_set_real (node, "angle1", angle1);  _node_set_real (node, "angle2", angle2);  if (fill)    _node_set_color (node, "fill", color);  else    _node_set_color (node, "stroke", color);}

static void xmlCloneTree(void* Pool,PXMLNode x,PXMLNode nx){  nx->eType=x->eType;  if(x->szCont)nx->szCont=xstrdup(Pool,x->szCont);  if(x->tAttrs)  {    pchar k,v;    tableFirst(x->tAttrs);    nx->tAttrs=tableNew(Pool,TABLE_FLAG_ALLOCNAME);    while(tableNext(x->tAttrs,&k,&v))    {      tableSet(nx->tAttrs,k,v);    }  }  if(x->hChildren)  {    PXMLNode p=x->pChildren;    PXMLNode np=NULL,c;    PHashLink l;    nx->hChildren=hashNewEx(Pool,x->hChildren->iCount);    while(p)    {      c=xmlNewChild(Pool,nx,p->eType);      if(np)np->pNext=c;      else nx->pChildren=c;      np=c;      //c->pParent=nx;      if(p->szName)      {        l=hashAdd(nx->hChildren,p->szName,c);        c->szName=l->szKey;      }      xmlCloneTree(Pool,p,c);      p=p->pNext;    }  }}

void KmlRenderer::renderLine(imageObj*, shapeObj *p, strokeStyleObj *style){    if (p->numlines == 0)      return;    if (PlacemarkNode == NULL)      PlacemarkNode = createPlacemarkNode(LayerNode, NULL);    if (!PlacemarkNode)      return;    addLineStyleToList(style);        SymbologyFlag[Line] = 1;    /*p->index > CurrentDrawnShapeIndexneed to be reviewd. Added since the hight      level code caches shapes when rendering lines*/    if (CurrentDrawnShapeIndex == -1 || p->index > CurrentDrawnShapeIndex)    {        xmlNodePtr geomNode = getGeomParentNode("LineString");        addAddRenderingSpecifications(geomNode);        addCoordsNode(geomNode, p->line[0].point, p->line[0].numpoints);                  /* more than one line => MultiGeometry*/        if (p->numlines > 1)        {            geomNode = getGeomParentNode("LineString"); // returns MultiGeom Node            for (int i=1; i<p->numlines; i++)            {                xmlNodePtr lineStringNode = xmlNewChild(geomNode, NULL, BAD_CAST "LineString", NULL);                addAddRenderingSpecifications(lineStringNode);                addCoordsNode(lineStringNode, p->line[i].point, p->line[i].numpoints);            }        }              CurrentDrawnShapeIndex = p->index;    }      }

static voiddraw_arc(DiaRenderer *self, 	 Point *center,	 real width, real height,	 real angle1, real angle2,	 Color *colour){  DiaSvgRenderer *renderer = DIA_SVG_RENDERER (self);  xmlNodePtr node;  char buf[512];  real rx = width / 2, ry = height / 2;  real sx=center->x + rx*cos(angle1*G_PI/180);  real sy=center->y - ry*sin(angle1*G_PI/180);  real ex=center->x + rx*cos(angle2*G_PI/180);  real ey=center->y - ry*sin(angle2*G_PI/180);  int swp = (angle2 > angle1) ? 0 : 1; /* not always drawing negative direction anymore */  int large_arc;  gchar sx_buf[DTOSTR_BUF_SIZE];  gchar sy_buf[DTOSTR_BUF_SIZE];  gchar rx_buf[DTOSTR_BUF_SIZE];  gchar ry_buf[DTOSTR_BUF_SIZE];  gchar ex_buf[DTOSTR_BUF_SIZE];  gchar ey_buf[DTOSTR_BUF_SIZE];  large_arc = (fabs(angle2 - angle1) >= 180);  node = xmlNewChild(renderer->root, renderer->svg_name_space, (const xmlChar *)"path", NULL);    xmlSetProp(node, (const xmlChar *)"style", (xmlChar *) get_draw_style(renderer, NULL, colour));  g_snprintf(buf, sizeof(buf), "M %s,%s A %s,%s 0 %d %d %s,%s",	     dia_svg_dtostr(sx_buf, sx), dia_svg_dtostr(sy_buf, sy),	     dia_svg_dtostr(rx_buf, rx), dia_svg_dtostr(ry_buf, ry),	     large_arc, swp,	     dia_svg_dtostr(ex_buf, ex), dia_svg_dtostr(ey_buf, ey) );  xmlSetProp(node, (const xmlChar *)"d", (xmlChar *) buf);}

static voidset_linejoin(DiaRenderer *self, LineJoin mode){  DrsRenderer *renderer = DRS_RENDERER (self);  xmlNodePtr node;  gchar *value = NULL;  switch(mode) {  case LINEJOIN_MITER:    value = "miter";    break;  case LINEJOIN_ROUND:    value = "round";    break;  case LINEJOIN_BEVEL:    value = "bevel";    break;  /* intentionally no default to let 'good' compilers warn about new constants*/  }  node =  xmlNewChild(renderer->root, NULL, (const xmlChar *)"set-linejoin", NULL);  xmlSetProp(node, (const xmlChar *)"mode",              value ? (xmlChar *)value : (xmlChar *)"?");}

static voidset_linecaps(DiaRenderer *self, LineCaps mode){  DrsRenderer *renderer = DRS_RENDERER (self);  xmlNodePtr node;  gchar *value = NULL;  switch(mode) {  case LINECAPS_BUTT:    value = "butt";    break;  case LINECAPS_ROUND:    value = "round";    break;  case LINECAPS_PROJECTING:    value = "projecting";    break;  /* intentionally no default to let 'good' compilers warn about new constants*/  }  node =  xmlNewChild(renderer->root, NULL, (const xmlChar *)"set-linecaps", NULL);  xmlSetProp(node, (const xmlChar *)"mode",              value ? (xmlChar *)value : (xmlChar *)"?");}

static xmlNodePtrbt_wavelevel_persistence_save (const BtPersistence * const persistence,    xmlNodePtr const parent_node){  const BtWavelevel *const self = BT_WAVELEVEL (persistence);  xmlNodePtr node = NULL;  GST_DEBUG ("PERSISTENCE::wavelevel");  if ((node =          xmlNewChild (parent_node, NULL, XML_CHAR_PTR ("wavelevel"), NULL))) {    // only serialize customizable properties    xmlNewProp (node, XML_CHAR_PTR ("root-note"),        XML_CHAR_PTR (bt_str_format_uchar (self->priv->root_note)));    xmlNewProp (node, XML_CHAR_PTR ("rate"),        XML_CHAR_PTR (bt_str_format_ulong (self->priv->rate)));    xmlNewProp (node, XML_CHAR_PTR ("loop-start"),        XML_CHAR_PTR (bt_str_format_long (self->priv->loop_start)));    xmlNewProp (node, XML_CHAR_PTR ("loop-end"),        XML_CHAR_PTR (bt_str_format_long (self->priv->loop_end)));  }  return node;}

void KmlRenderer::addCoordsNode(xmlNodePtr parentNode, pointObj *pts, int numPts){  char lineBuf[128];  xmlNodePtr coordsNode = xmlNewChild(parentNode, NULL, BAD_CAST "coordinates", NULL);  xmlNodeAddContent(coordsNode, BAD_CAST "/n");  for (int i=0; i<numPts; i++) {    if( mElevationFromAttribute ) {      sprintf(lineBuf, "/t%.8f,%.8f,%.8f/n", pts[i].x, pts[i].y, mCurrentElevationValue);    } else if (AltitudeMode == relativeToGround || AltitudeMode == absolute) {#ifdef USE_POINT_Z_M      sprintf(lineBuf, "/t%.8f,%.8f,%.8f/n", pts[i].x, pts[i].y, pts[i].z);#else      msSetError(MS_MISCERR, "Z coordinates support not available  (mapserver not compiled with USE_POINT_Z_M option)", "KmlRenderer::addCoordsNode()");#endif    } else      sprintf(lineBuf, "/t%.8f,%.8f/n", pts[i].x, pts[i].y);    xmlNodeAddContent(coordsNode, BAD_CAST lineBuf);  }  xmlNodeAddContent(coordsNode, BAD_CAST "/t");}

static voiddraw_text_line(DiaRenderer *self, TextLine *text_line,	       Point *pos, Alignment alignment, Color *colour){  DiaSvgRenderer *renderer = DIA_SVG_RENDERER (self);  xmlNodePtr node;  DiaFont *font = text_line_get_font(text_line); /* no reference? */  real font_height = text_line_get_height(text_line);  gchar d_buf[G_ASCII_DTOSTR_BUF_SIZE];    node = xmlNewChild(renderer->root, renderer->svg_name_space, (const xmlChar *)"text", 		     (xmlChar *) text_line_get_string(text_line));  /* not using the renderers font but the textlines */  node_set_text_style(node, renderer, font, font_height, alignment, colour);  dia_svg_dtostr(d_buf, pos->x);  xmlSetProp(node, (const xmlChar *)"x", (xmlChar *) d_buf);  dia_svg_dtostr(d_buf, pos->y);  xmlSetProp(node, (const xmlChar *)"y", (xmlChar *) d_buf);  dia_svg_dtostr(d_buf, text_line_get_width(text_line));  xmlSetProp(node, (const xmlChar*)"textLength", (xmlChar *) d_buf);}

/* Create a new element with string value */int ermXmlNewString(const erManifest *pCtx, const char *parentExpress, const char *name, const char *content){    xmlXPathObjectPtr xpathObj = LocateTo(parentExpress, pCtx);    if (NULL == xpathObj)        return RET_ERR;    xmlNodeSetPtr nodes = xpathObj->nodesetval;    /* MvdW: we need to encode special chars in the input */    xmlChar *xmlString = xmlEncodeSpecialChars(pCtx->pDoc, (xmlChar *) content);    if (nodes && nodes->nodeTab[0])    {        /*xmlNodePtr node = */ xmlNewChild(nodes->nodeTab[0],                                           NULL, BAD_CAST name, // MvdW: this should ALSO be encoded!                                           xmlString);        xmlFree(xmlString);        xmlXPathFreeObject(xpathObj);        return RET_OK;    }    xmlXPathFreeObject(xpathObj);    return RET_ERR;}

static voidmpp_write_overridden_date (MrpParser      *parser,			   xmlNodePtr      parent,			   MrpDateWithDay *dd){	NodeEntry  *entry;	xmlNodePtr  child;	gchar      *str;	entry = g_hash_table_lookup (parser->day_hash, dd->day);	if (entry) {		child = xmlNewChild (parent, NULL, "day", NULL);		str = mrp_time_format ("%Y%m%d", dd->date);		xmlSetProp (child, "date", str);		g_free (str);		xmlSetProp (child, "type", "day-type"); 		mpp_xml_set_int (child, "id", entry->id);	} 	g_free (dd);}

static voiddraw_ellipse(DiaRenderer *self, 	     Point *center,	     real width, real height,	     Color *fill, Color *stroke){  DiaSvgRenderer *renderer = DIA_SVG_RENDERER (self);  xmlNodePtr node;  gchar d_buf[DTOSTR_BUF_SIZE];  node = xmlNewChild(renderer->root, renderer->svg_name_space, (const xmlChar *)"ellipse", NULL);  xmlSetProp(node, (const xmlChar *)"style", (xmlChar *) get_draw_style (renderer, fill, stroke));  dia_svg_dtostr(d_buf, center->x);  xmlSetProp(node, (const xmlChar *)"cx", (xmlChar *) d_buf);  dia_svg_dtostr(d_buf, center->y);  xmlSetProp(node, (const xmlChar *)"cy", (xmlChar *) d_buf);  dia_svg_dtostr(d_buf, width / 2);  xmlSetProp(node, (const xmlChar *)"rx", (xmlChar *) d_buf);  dia_svg_dtostr(d_buf, height / 2);  xmlSetProp(node, (const xmlChar *)"ry", (xmlChar *) d_buf);}

xmlNodePtr add_resouce_list_attribute(    const char *nodeTag,     /* I tag to use on the resouce head-node */    xmlNodePtr *attr_node,   /* M attribute head-node */     xmlNodePtr *res_node,    /* M Resource_List/resources_used head-node */     svrattrl   *pal)         /* I encoded attribute structure */  {  xmlNodePtr attributeHeadNode = *attr_node;  xmlNodePtr resourceHeadNode = *res_node;  xmlNodePtr resourceNode = NULL;  if (!resourceHeadNode)    if ((resourceHeadNode = xmlNewNode(NULL, (xmlChar *)nodeTag)))      {      xmlAddChild(attributeHeadNode, resourceHeadNode);      *res_node = resourceHeadNode;      }  if (pal->al_atopl.resource)    resourceNode = xmlNewChild(resourceHeadNode, NULL, (xmlChar *)pal->al_atopl.resource, (xmlChar *)pal->al_atopl.value);  return resourceNode;  }

static xmlNodePtr _find_xml_node(char *mount, source_xml_t **list, xmlNodePtr root){    source_xml_t *node, *node2;    int found = 0;    /* search for existing node */    node = *list;    while (node) {        if (strcmp(node->mount, mount) == 0) {            found = 1;            break;        }        node = node->next;    }    if (found) return node->node;    /* if we didn't find it, we must build it and add it to the list */    /* build node */    node = (source_xml_t *)malloc(sizeof(source_xml_t));    node->mount = strdup(mount);    node->node = xmlNewChild(root, NULL, "source", NULL);    xmlSetProp(node->node, "mount", mount);    node->next = NULL;    /* add node */    if (*list == NULL) {        *list = node;    } else {        node2 = *list;        while (node2->next) node2 = node2->next;        node2->next = node;    }    return node->node;}

bool create_jpeg( const char *filename, xmlNodePtr parent ) {	char *name = get_name_from_filename( filename );	// parse thru the jpeg to find width and height	FILE *fp = fopen( filename, "rb" );	char tmp[TMP_STRLEN];	if( !fp ) return false;			int width=-1, height=-1;	while( !feof( fp ) ) { // could do a && width==-1 here, but that captures preview imgs...		if( fgetc(fp) == 0xff ) {			if( fgetc(fp) == 0xc0 ) {				// StartOfFrame				// skip length and precision (UGLY, eh?)				fgetc(fp); fgetc(fp); fgetc(fp);								// read height, width				height = getJpegWord( fp );				width = getJpegWord( fp );			}		}	}		xmlNodePtr node = xmlNewChild( parent, NULL, (const xmlChar *)"jpeg", NULL );	snprintf(tmp,TMP_STRLEN,"%i", width);	xmlSetProp( node, (const xmlChar *)"width", (const xmlChar *)&tmp );	snprintf(tmp,TMP_STRLEN,"%i", height);	xmlSetProp( node, (const xmlChar *)"height", (const xmlChar *)&tmp );	xmlSetProp( node, (const xmlChar *)"file", (const xmlChar *)filename );	xmlSetProp( node, (const xmlChar *)"name", (const xmlChar *)name );	if( name ) delete name;			return true;}

static void uwsgi_webdav_do_prop_update(struct wsgi_request *wsgi_req, xmlNode *prop, xmlNode *response, char *filename, uint8_t action) {	xmlNode *node;        // search for "prop"        for (node = prop->children; node; node = node->next) {		if (node->type == XML_ELEMENT_NODE) {			xmlNode *propstat = xmlNewChild(response, NULL, BAD_CAST "propstat", NULL);			xmlNode *r_prop = xmlNewChild(propstat, NULL, BAD_CAST "prop" , NULL);			xmlNode *new_prop = xmlNewChild(r_prop, NULL, node->name, NULL);			if (node->ns) {				xmlNsPtr xattr_ns = xmlNewNs(new_prop, node->ns->href, NULL);                                xmlSetNs(new_prop, xattr_ns);			}			if (action == 0) {				if (uwsgi_webdav_prop_set(filename, (char *) node->name, node->ns ? (char *) node->ns->href : NULL, node->children ? (char *) node->children->content : "")) {					char *r_status = uwsgi_concat2n(wsgi_req->protocol, wsgi_req->protocol_len, " 403 Forbidden", 14);					xmlNewChild(r_prop, NULL, BAD_CAST "status", BAD_CAST r_status);					free(r_status);				}				else {					char *r_status = uwsgi_concat2n(wsgi_req->protocol, wsgi_req->protocol_len, " 200 OK", 7);					xmlNewChild(r_prop, NULL, BAD_CAST "status", BAD_CAST r_status);					free(r_status);				}			}			else if (action == 1) {				if (uwsgi_webdav_prop_del(filename, (char *) node->name, node->ns ? (char *) node->ns->href : NULL)) {					char *r_status = uwsgi_concat2n(wsgi_req->protocol, wsgi_req->protocol_len, " 403 Forbidden", 14);					xmlNewChild(r_prop, NULL, BAD_CAST "status", BAD_CAST r_status);					free(r_status);				}				else {					char *r_status = uwsgi_concat2n(wsgi_req->protocol, wsgi_req->protocol_len, " 200 OK", 7);					xmlNewChild(r_prop, NULL, BAD_CAST "status", BAD_CAST r_status);					free(r_status);				}			}		}	}}

static voidmpp_write_string_list (xmlNodePtr   node,		       MrpProperty *property,		       MrpObject   *object){	xmlNodePtr   child;	GArray      *array;	GValue      *value;	gint         i;	mrp_object_get (object, mrp_property_get_name (property), &array, NULL);	if (!array) {		return;	}	for (i = 0; i < array->len; i++) {		value = g_array_index (array, GValue *, i);		child = xmlNewChild (node, NULL, "list-item", NULL);		xmlSetProp (child, "value", g_value_get_string (value));	}	g_array_free (array, TRUE);}

static void op_history_insert(xmlNode *resource_xml,	struct operation_history *oh){	xmlNode *op;	char key[255];	char magic[255];	qb_enter();	op = xmlNewChild(resource_xml, NULL, BAD_CAST "lrm_rsc_op", NULL);	xmlNewProp(op, BAD_CAST "id", BAD_CAST oh->rsc_id);	xmlNewProp(op, BAD_CAST "operation", BAD_CAST oh->operation);	xml_new_int_prop(op, "call-id", oh->call_id);	xml_new_int_prop(op, "rc-code", oh->rc);	xml_new_int_prop(op, "interval", oh->interval);	xml_new_time_prop(op, "last-run", oh->last_run);	xml_new_time_prop(op, "last-rc-change", oh->last_rc_change);	snprintf(key, 255, "%d:%d:%d:%s",		oh->action_id, oh->graph_id, oh->target_outcome, crmd_uuid);	xmlNewProp(op, BAD_CAST "transition-key", BAD_CAST key);	snprintf(magic, 255, "0:%d:%s", oh->rc, key);	xmlNewProp(op, BAD_CAST "transition-magic", BAD_CAST magic);	xmlNewProp(op, BAD_CAST "op-digest", BAD_CAST oh->op_digest);	xmlNewProp(op, BAD_CAST "crm-debug-origin", BAD_CAST __func__);	xmlNewProp(op, BAD_CAST "crm_feature_set", BAD_CAST PE_CRM_VERSION);	xmlNewProp(op, BAD_CAST "op-status", BAD_CAST "0");	xmlNewProp(op, BAD_CAST "exec-time", BAD_CAST "0");	xmlNewProp(op, BAD_CAST "queue-time", BAD_CAST "0");	qb_leave();}

static voiddraw_polyline(DiaRenderer *self, 	      Point *points, int num_points, 	      Color *line_colour){  DiaSvgRenderer *renderer = DIA_SVG_RENDERER (self);  int i;  xmlNodePtr node;  GString *str;  gchar px_buf[DTOSTR_BUF_SIZE];  gchar py_buf[DTOSTR_BUF_SIZE];  node = xmlNewChild(renderer->root, renderer->svg_name_space, (const xmlChar *)"polyline", NULL);  xmlSetProp(node, (const xmlChar *)"style", (xmlChar *) get_draw_style(renderer, NULL, line_colour));  str = g_string_new(NULL);  for (i = 0; i < num_points; i++)    g_string_append_printf(str, "%s,%s ",		      dia_svg_dtostr(px_buf, points[i].x),		      dia_svg_dtostr(py_buf, points[i].y) );  xmlSetProp(node, (const xmlChar *)"points", (xmlChar *) str->str);  g_string_free(str, TRUE);}

static xmlNodePtrtaxtable_dom_tree_create (GncTaxTable *table){    xmlNodePtr ret, entries;    GList *list;    ret = xmlNewNode(NULL, BAD_CAST gnc_taxtable_string);    xmlSetProp(ret, BAD_CAST "version", BAD_CAST taxtable_version_string);    maybe_add_guid(ret, taxtable_guid_string, table);    xmlAddChild(ret, text_to_dom_tree (taxtable_name_string,                                       gncTaxTableGetName (table)));    xmlAddChild(ret, int_to_dom_tree (taxtable_refcount_string,                                      gncTaxTableGetRefcount (table)));    xmlAddChild(ret, int_to_dom_tree (taxtable_invisible_string,                                      gncTaxTableGetInvisible (table)));    /* We should not be our own child */    if (gncTaxTableGetChild(table) != table)        maybe_add_guid(ret, taxtable_child_string, gncTaxTableGetChild (table));    maybe_add_guid(ret, taxtable_parent_string, gncTaxTableGetParent (table));    entries = xmlNewChild (ret, NULL, BAD_CAST taxtable_entries_string, NULL);    for (list = gncTaxTableGetEntries (table); list; list = list->next)    {        GncTaxTableEntry *entry = static_cast<decltype(entry)>(list->data);        xmlAddChild(entries, ttentry_dom_tree_create (entry));    }    /* xmlAddChild won't do anything with a NULL, so tests are superfluous. */    xmlAddChild(ret, qof_instance_slots_to_dom_tree(taxtable_slots_string,                                                    QOF_INSTANCE(table)));    return ret;}

static voidinf_adopted_session_to_xml_sync_foreach_user_func(InfUser* user,                                                  gpointer user_data){  InfAdoptedRequestLog* log;  InfAdoptedSessionToXmlSyncForeachData* data;  InfAdoptedSessionClass* session_class;  guint i;  guint end;  xmlNodePtr xml;  InfAdoptedRequest* request;  g_assert(INF_ADOPTED_IS_USER(user));  data = (InfAdoptedSessionToXmlSyncForeachData*)user_data;  log = inf_adopted_user_get_request_log(INF_ADOPTED_USER(user));  end = inf_adopted_request_log_get_end(log);  session_class = INF_ADOPTED_SESSION_GET_CLASS(data->session);  g_assert(session_class->request_to_xml != NULL);  for(i = inf_adopted_request_log_get_begin(log); i < end; ++ i)  {    request = inf_adopted_request_log_get_request(log, i);    xml = xmlNewChild(      data->parent_xml,      NULL,      (const xmlChar*)"sync-request",      NULL    );    /* TODO: Diff to previous request? */    session_class->request_to_xml(data->session, xml, request, NULL, TRUE);    xmlAddChild(data->parent_xml, xml);  }}

static voidmpp_write_group (MrpParser *parser, xmlNodePtr parent, MrpGroup *group){	NodeEntry  *entry;	xmlNodePtr  node;	gchar      *name, *admin_name, *admin_phone, *admin_email;	g_return_if_fail (MRP_IS_GROUP (group));	node = xmlNewChild (parent,                            NULL,			    "group",			    NULL);	entry = g_hash_table_lookup (parser->group_hash, group);	entry->node = node;	mpp_xml_set_int (node, "id", entry->id);	g_object_get (group,		      "name", &name,		      "manager-name", &admin_name,		      "manager-phone", &admin_phone,		      "manager-email", &admin_email,		      NULL);	xmlSetProp (node, "name", name);	xmlSetProp (node, "admin-name", admin_name);	xmlSetProp (node, "admin-phone", admin_phone);	xmlSetProp (node, "admin-email", admin_email);	g_free (name);	g_free (admin_name);	g_free (admin_phone);	g_free (admin_email);}

static voidvfolder_export (nodePtr node,                xmlNodePtr cur,                gboolean trusted){	vfolderPtr	vfolder = (vfolderPtr) node->data;	xmlNodePtr	ruleNode;	rulePtr		rule;	GSList		*iter;	debug_enter ("vfolder_export");		g_assert (TRUE == trusted);		xmlNewProp (cur, BAD_CAST"matchType", BAD_CAST (vfolder->itemset->anyMatch?"any":"all"));	iter = vfolder->itemset->rules;	while (iter) {		rule = iter->data;		ruleNode = xmlNewChild (cur, NULL, BAD_CAST"outline", NULL);		xmlNewProp (ruleNode, BAD_CAST"type", BAD_CAST "rule");		xmlNewProp (ruleNode, BAD_CAST"text", BAD_CAST rule->ruleInfo->title);		xmlNewProp (ruleNode, BAD_CAST"rule", BAD_CAST rule->ruleInfo->ruleId);		xmlNewProp (ruleNode, BAD_CAST"value", BAD_CAST rule->value);		if (rule->additive)			xmlNewProp (ruleNode, BAD_CAST"additive", BAD_CAST "true");		else			xmlNewProp (ruleNode, BAD_CAST"additive", BAD_CAST "false");		iter = g_slist_next (iter);	}		debug1 (DEBUG_CACHE, "adding vfolder: title=%s", node_get_title (node));	debug_exit ("vfolder_export");}

xmlNodePtrcreate_param_node (xmlDocPtr doc,                   SoupSoapParam *param,                   xmlNodePtr parent_node){	xmlNodePtr node = xmlNewChild (parent_node, NULL,	                               BAD_CAST soup_soap_param_get_name (param),	                               NULL);	SoupSoapParam *param_child;	if (SOUP_SOAP_IS_PARAM_GROUP (param))	{		GList *elements =			soup_soap_param_group_get_elements (SOUP_SOAP_PARAM_GROUP (param));		GList *curr_element = elements;		while (curr_element)		{			param_child = curr_element->data;			create_param_node (doc, param_child, node);			curr_element = g_list_next (curr_element);		}	}	else	{		xmlChar *content = xmlEncodeEntitiesReentrant (doc,		                                               BAD_CAST soup_soap_param_get_value (param));		xmlNodeSetContent (node, content);		xmlFree (content);	}	return node;}

/** * rb_playlist_source_save_to_xml: * @source: the playlist source to save * @parent_node: libxml node below which to save the playlist * * Converts the playlist to XML format, below the specified * parent node. */voidrb_playlist_source_save_to_xml (RBPlaylistSource *source,				xmlNodePtr parent_node){	xmlNodePtr node;	xmlChar *name;	GSettings *settings;	RBPlaylistSourceClass *klass = RB_PLAYLIST_SOURCE_GET_CLASS (source);	g_return_if_fail (RB_IS_PLAYLIST_SOURCE (source));	node = xmlNewChild (parent_node, NULL, RB_PLAYLIST_PLAYLIST, NULL);	g_object_get (source, "name", &name, NULL);	xmlSetProp (node, RB_PLAYLIST_NAME, name);	g_free (name);	g_object_get (source, "settings", &settings, NULL);	if (settings) {		char *p;		xmlSetProp (node,			    RB_PLAYLIST_SHOW_BROWSER,			    (xmlChar *)(g_settings_get_boolean (settings, "show-browser") ? "true" : "false"));		p = g_strdup_printf ("%d", g_settings_get_int (settings, "paned-position"));		xmlSetProp (node, RB_PLAYLIST_BROWSER_POSITION, (xmlChar *)p);		g_free (p);		xmlSetProp (node, RB_PLAYLIST_SEARCH_TYPE, (xmlChar *)g_settings_get_string (settings, "search-type"));		g_object_unref (settings);	}	klass->impl_save_contents_to_xml (source, node);	source->priv->dirty = FALSE;}