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

int gen_nc_xml(const struct nc_state_t *nc_state_param){    int ret = EUCA_ERROR;    char path[MAX_PATH] = "";    xmlDocPtr doc = NULL;    xmlNodePtr nc = NULL;    xmlNodePtr version = NULL;    xmlNodePtr enabled = NULL;    INIT();    pthread_mutex_lock(&xml_mutex);    {        doc = xmlNewDoc(BAD_CAST "1.0");        nc = xmlNewNode(NULL, BAD_CAST "nc");        xmlDocSetRootElement(doc, nc);        version = xmlNewChild(nc, NULL, BAD_CAST "version", BAD_CAST(nc_state_param->version));        enabled = xmlNewChild(nc, NULL, BAD_CAST "enabled", BAD_CAST(nc_state_param->is_enabled ? "true" : "false"));        snprintf(path, sizeof(path), EUCALYPTUS_NC_STATE_FILE, nc_state.home);        ret = write_xml_file(doc, "global", path, "nc");        xmlFreeDoc(doc);    }    pthread_mutex_unlock(&xml_mutex);    return (ret);}

BOOL CLibXmlXmlParser::SetElementValue( LPCTSTR strElementName, LPCTSTR strValue ){    BOOL bResult = FALSE;    if( this->m_pXMLRootNode )    {        xmlNodePtr pChild = this->m_pXMLRootNode->children;        while( pChild )        {            if( xmlStrcmp( pChild->name , BAD_CAST(strElementName) ) == 0 )            {                break;            }            pChild = pChild->next;        }        if( !pChild )        {            //			pChild = xmlNewNode(NULL , BAD_CAST ( strEleName ));            pChild = xmlNewChild( this->m_pXMLRootNode, NULL, BAD_CAST(strElementName), BAD_CAST(strValue) );        }        if( pChild )        {            xmlNodeSetContent( pChild,  BAD_CAST( strValue ) );            //pChild->content = BAD_CAST( strValue );        }        bResult = ( NULL != pChild );    }    // 写完保存。    bResult &= this->SaveXML();    return bResult;}

static int parseHttpStyle(xmlDocPtr doc, xmlNodePtr cur){	xmlChar * temp;	int ret=1;	cur = cur->xmlChildrenNode;	while(cur!=NULL){		if(!xmlStrcmp(cur->name,(const xmlChar *)"packetLength")){			temp = xmlNodeListGetString(doc,cur->xmlChildrenNode,1);			if(temp!=NULL){				httpConTemp->packetLength=atoi((char *)temp);				if(httpConTemp->packetLength>MAXLENGTH)					httpConTemp->packetLength=MAXLENGTH;			}			else{				printf("X Error: read xml 'style.packetLength' Wrong./n");				ret &= 0;			}			xmlFree(temp);		}		else if(!xmlStrcmp(cur->name,(const xmlChar *)"dataHeader")){			parseHttpDataHeader(doc,cur);		}		else if(!xmlStrcmp(cur->name,(const xmlChar *)"data")){			temp = xmlGetProp(cur,BAD_CAST("random"));			if(xmlStrcmp(temp,BAD_CAST("true"))==0)				httpConTemp->dataRandom = 1;			else				httpConTemp->dataRandom = 2;			xmlFree(temp);			parseHttpData(doc,cur,httpConTemp->dataRandom);		}		cur = cur->next;	}	return ret;}

/**/brief Save this Planet to an xml node */xmlNodePtr Planet::ToXMLNode(string componentName) {	char buff[256];	xmlNodePtr section = xmlNewNode(NULL, BAD_CAST componentName.c_str() );	xmlNewChild(section, NULL, BAD_CAST "name", BAD_CAST this->GetName().c_str() );	xmlNewChild(section, NULL, BAD_CAST "alliance", BAD_CAST this->GetAlliance()->GetName().c_str() );	snprintf(buff, sizeof(buff), "%d", (int)this->GetWorldPosition().GetX() );	xmlNewChild(section, NULL, BAD_CAST "x", BAD_CAST buff );	snprintf(buff, sizeof(buff), "%d", (int)this->GetWorldPosition().GetY() );	xmlNewChild(section, NULL, BAD_CAST "y", BAD_CAST buff );	xmlNewChild(section, NULL, BAD_CAST "landable", BAD_CAST (this->GetLandable()?"1":"0") );	snprintf(buff, sizeof(buff), "%d", this->GetTraffic() );	xmlNewChild(section, NULL, BAD_CAST "traffic", BAD_CAST buff );	xmlNewChild(section, NULL, BAD_CAST "image", BAD_CAST this->GetImage()->GetPath().c_str() );	snprintf(buff, sizeof(buff), "%d", this->GetMilitiaSize() );	xmlNewChild(section, NULL, BAD_CAST "militia", BAD_CAST buff );	snprintf(buff, sizeof(buff), "%d", this->GetInfluence() );	xmlNewChild(section, NULL, BAD_CAST "sphereOfInfluence", BAD_CAST buff );	list<Technology*> techs = this->GetTechnologies();	for( list<Technology*>::iterator it = techs.begin(); it!=techs.end(); ++it ){		xmlNewChild(section, NULL, BAD_CAST "technology", BAD_CAST (*it)->GetName().c_str() );	}	return section;}

static voidxml_out_string (xmlTextWriterPtr xml, const char *name, const char *value){    xmlTextWriterStartElement (xml, BAD_CAST ("option"));    xmlTextWriterWriteAttribute (xml, BAD_CAST ("name"), BAD_CAST (name));    xmlTextWriterWriteAttribute (xml, BAD_CAST ("value"), BAD_CAST (value));    xmlTextWriterEndElement (xml);}

History::Contact::Contact (boost::shared_ptr<Ekiga::ContactCore> _contact_core,			   boost::shared_ptr<xmlDoc> _doc,			   xmlNodePtr _node):  contact_core(_contact_core), doc(_doc), node(_node){  xmlChar* xml_str = NULL;  xml_str = xmlGetProp (node, (const xmlChar *)"type");  if (xml_str != NULL) {    m_type = (call_type)(xml_str[0] - '0'); // FIXME: I don't like it!    xmlFree (xml_str);  }  xml_str = xmlGetProp (node, (const xmlChar *)"uri");  if (xml_str != NULL) {    uri = (const char *)xml_str;    xmlFree (xml_str);  }  for (xmlNodePtr child = node->children ;       child != NULL ;       child = child->next) {    if (child->type == XML_ELEMENT_NODE        && child->name != NULL) {      if (xmlStrEqual (BAD_CAST ("name"), child->name)) {        xml_str = xmlNodeGetContent (child);	if (xml_str != NULL)	  name = (const char *)xml_str;        xmlFree (xml_str);      }      if (xmlStrEqual (BAD_CAST ("call_start"), child->name)) {        xml_str = xmlNodeGetContent (child);	if (xml_str != NULL)	  call_start = (time_t) atoi ((const char *) xml_str);        xmlFree (xml_str);      }      if (xmlStrEqual (BAD_CAST ("call_duration"), child->name)) {        xml_str = xmlNodeGetContent (child);	if (xml_str != NULL)	  call_duration = (const char *) xml_str;        xmlFree (xml_str);      }    }  }}

voidxen_init(void){    responsePath =        xmlXPathCompile(            BAD_CAST(                "/methodResponse/params/param/value/struct/member/value"));    faultPath =        xmlXPathCompile(            BAD_CAST("/methodResponse/fault/value/struct/member/value"));}

static voidxml_out_binding (xmlTextWriterPtr xml, const char *name, unsigned int value){    char string[1024];    snprintf (string, 1024, "%u", value);    xmlTextWriterStartElement (xml, BAD_CAST ("binding"));    xmlTextWriterWriteAttribute (xml, BAD_CAST ("name"), BAD_CAST (name));    xmlTextWriterWriteAttribute (xml, BAD_CAST ("binding"), BAD_CAST (string));    xmlTextWriterEndElement (xml);}

static int parsePacketTime (xmlDocPtr doc, xmlNodePtr cur){	xmlChar * temp;	int flag_ptime_random;	int ptime_value,ptime_meth;	int ret=1;	temp = xmlGetProp(cur,BAD_CAST("random"));	if(temp!=NULL){		if(xmlStrcmp(temp,BAD_CAST("false"))==0)			flag_ptime_random = 2;		else			flag_ptime_random = 1;		xmlFree(temp);		cur = cur->xmlChildrenNode;		while(cur!=NULL){			if(flag_ptime_random==2&&!xmlStrcmp(cur->name,(const xmlChar *)"value")){				temp=xmlNodeListGetString(doc,cur->xmlChildrenNode,1);				if(temp!=NULL){					ptime_value = atoi((char *)temp);				}				else{					printf("X Error: read xml 'packetTime.value' Wrong./n");					ret &= 0;				}				xmlFree(temp);			}			else if(flag_ptime_random==1&&!xmlStrcmp(cur->name,(const xmlChar *)"scope")){				ret &= parsePacketTimeScope(doc,cur);			}			else if(flag_ptime_random==1&&!xmlStrcmp(cur->name,(const xmlChar *)"meth")){				temp=xmlNodeListGetString(doc,cur->xmlChildrenNode,1);				if(temp!=NULL){					ptime_meth = atoi((char *)temp);				}				else{					printf("X Error: read xml 'packetTime.meth' Wrong./n");					ret &= 0;				}				xmlFree(temp);			}			cur = cur->next;		}		ddosc->packetTimels = get_packetTime(flag_ptime_random,											ptime_value,											ptime_from,ptime_to,ptime_meth);	}	else{		printf("X Error: read xml 'packetTime.random' Wrong./n");		xmlFree(temp);		return 0;	}	return ret;}

History::Contact::Contact (Ekiga::ServiceCore &_core,			   xmlNodePtr _node):  core(_core), node(_node){  xmlChar *xml_str;  contact_core    = dynamic_cast<Ekiga::ContactCore*>(core.get ("contact-core"));  xml_str = xmlGetProp (node, (const xmlChar *)"type");  if (xml_str != NULL)    m_type = (call_type)(xml_str[0] - '0'); // FIXME: I don't like it!  xmlFree (xml_str);  xml_str = xmlGetProp (node, (const xmlChar *)"uri");  if (xml_str != NULL)    uri = (const char *)xml_str;  xmlFree (xml_str);  for (xmlNodePtr child = node->children ;       child != NULL ;       child = child->next) {    if (child->type == XML_ELEMENT_NODE        && child->name != NULL) {      if (xmlStrEqual (BAD_CAST ("name"), child->name)) {        xml_str = xmlNodeGetContent (child);	if (xml_str != NULL)	  name = (const char *)xml_str;        xmlFree (xml_str);      }      if (xmlStrEqual (BAD_CAST ("call_start"), child->name)) {        xml_str = xmlNodeGetContent (child);	if (xml_str != NULL)	  call_start = (time_t) atoi ((const char *) xml_str);        xmlFree (xml_str);      }      if (xmlStrEqual (BAD_CAST ("call_duration"), child->name)) {        xml_str = xmlNodeGetContent (child);	if (xml_str != NULL)	  call_duration = (const char *) xml_str;        xmlFree (xml_str);      }    }  }}

static xar_file_t xar_link_lookup(xar_t x, dev_t dev, ino_t ino, xar_file_t f) {	char key[32];	xar_file_t ret;	memset(key, 0, sizeof(key));	snprintf(key, sizeof(key)-1, "%08" DEV_HEXSTRING "%08" INO_HEXSTRING, DEV_CAST dev, INO_CAST ino);	ret = xmlHashLookup(XAR(x)->ino_hash, BAD_CAST(key));	if( ret == NULL ) {		xmlHashAddEntry(XAR(x)->ino_hash, BAD_CAST(key), XAR_FILE(f));		return NULL;	}	return ret;}

/*------------------------------------------------------------------------------*/static voidcluster_getparam(int thr_nb, void *data, cl_error_desc_t *err_desc){  xmlDocPtr doc = NULL;  xmlNodePtr exanodes_node;  int ret;  exalog_debug("getparam");  /* Create XML document */  doc = xmlNewDoc(BAD_CAST("1.0"));  if (doc == NULL)  {    set_error(err_desc, -EXA_ERR_XML_INIT, "Failed to create result document");    return;  }  exanodes_node = xmlNewNode(NULL, BAD_CAST("Exanodes"));  if (exanodes_node == NULL)  {    set_error(err_desc, -EXA_ERR_XML_INIT,	      "Failed to create node in result document");    xmlFreeDoc(doc);    return;  }  xmlDocSetRootElement(doc, exanodes_node);  ret = build_response(exanodes_node);  if (ret ==  EXA_SUCCESS)    {      xmlChar *xmlchar_doc;      int buf_size;      xmlDocDumpFormatMemory(doc, &xmlchar_doc, &buf_size, 1);      send_payload_str((char *)xmlchar_doc);      xmlFree(xmlchar_doc);    }  xmlFreeDoc(doc);  set_error(err_desc, ret, NULL);}

const char * config_get_value(const char * _xpath) {    xmlXPathObjectPtr xmlobject = NULL;    const xmlChar * xpath = BAD_CAST(_xpath);    const xmlChar * value = NULL;            /* Rquete XPath*/    xmlobject = xmlXPathEval(xpath, config->context);    if (!xmlobject)        return NULL;        if (xmlobject->type == XPATH_NODESET) {         if (xmlobject->nodesetval) {             /* nodeNr = nb nodes in struct nodesetval */             if (xmlobject->nodesetval->nodeNr > 0) {                xmlNodePtr n;		                n = xmlobject->nodesetval->nodeTab[0];                if ((n->type == XML_TEXT_NODE) ||                     (n->type == XML_CDATA_SECTION_NODE))                    value = n->content;            }        }    }        xmlXPathFreeObject(xmlobject);        return (char *)value;}

xmlNodeSetPtr getXNodes(xmlXPathContextPtr context, const gchar *xpath) {  xmlXPathObjectPtr xobj = xmlXPathEvalExpression(BAD_CAST(xpath), context);  xmlNodeSetPtr ret = xobj->nodesetval;  xmlXPathFreeNodeSetList(xobj);  return ret;}

LM::Bank::Bank (boost::shared_ptr<Ekiga::PersonalDetails> details_,		boost::shared_ptr<Dialect> dialect_,		boost::shared_ptr<Cluster> cluster_):  details(details_), cluster(cluster_), dialect(dialect_), doc (NULL){  gchar* c_raw = gm_conf_get_string (JABBER_KEY);  if (c_raw != NULL) { // we already have it in store    const std::string raw = c_raw;    doc = xmlRecoverMemory (raw.c_str (), raw.length ());    xmlNodePtr root = xmlDocGetRootElement (doc);    if (root == NULL) {      root = xmlNewDocNode (doc, NULL, BAD_CAST "list", NULL);      xmlDocSetRootElement (doc, root);    }    for (xmlNodePtr child = root->children; child != NULL; child = child->next) {      if (child->type == XML_ELEMENT_NODE && child->name != NULL && xmlStrEqual (BAD_CAST ("entry"), child->name)) {	boost::shared_ptr<Account> account (new Account (details, dialect, cluster, child));	add (account);      }    }    g_free (c_raw);  } else { // create a new XML document    doc = xmlNewDoc (BAD_CAST "1.0");    xmlNodePtr root = xmlNewDocNode (doc, NULL, BAD_CAST "list", NULL);    xmlDocSetRootElement (doc, root);  }}

voidLocal::Presentity::rename_group (const std::string old_name,				 const std::string new_name){  bool old_name_present = false;  bool already_in_new_name = false;  std::set<xmlNodePtr> nodes_to_remove;  /* remove the old name's node   * and check if we aren't already in the new name's group   */  for (xmlNodePtr child = node->children ;       child != NULL ;       child = child->next) {    if (child->type == XML_ELEMENT_NODE        && child->name != NULL) {      if (xmlStrEqual (BAD_CAST ("group"), child->name)) {	xmlChar* xml_str = xmlNodeGetContent (child);	if (xml_str != NULL) {	  if (!xmlStrcasecmp ((const xmlChar*)old_name.c_str (), xml_str)) {	    nodes_to_remove.insert (child); // don't free what we loop on!            old_name_present = true;	  }	  if (!xmlStrcasecmp ((const xmlChar*)new_name.c_str (), xml_str)) {	    already_in_new_name = true;	  }	  xmlFree (xml_str);	}      }    }  }  // ok, now we can clean up!  for (std::set<xmlNodePtr>::iterator iter = nodes_to_remove.begin ();       iter != nodes_to_remove.end ();       ++iter) {    xmlUnlinkNode (*iter);    xmlFreeNode (*iter);  }  if (old_name_present && !already_in_new_name) {    xmlNewChild (node, NULL,		 BAD_CAST "group",		 BAD_CAST robust_xmlEscape (node->doc,					    new_name).c_str ());  }  updated ();  trigger_saving ();}

voidRL::Heap::parse_doc (std::string raw){  doc = std::tr1::shared_ptr<xmlDoc> (xmlRecoverMemory (raw.c_str (), raw.length ()), xmlFreeDoc);  if ( !doc)    doc = std::tr1::shared_ptr<xmlDoc> (xmlNewDoc (BAD_CAST "1.0"), xmlFreeDoc);  xmlNodePtr doc_root = xmlDocGetRootElement (doc.get ());  if (doc_root == NULL      || doc_root->name == NULL      || !xmlStrEqual (BAD_CAST "resource-lists", doc_root->name)) {    std::cout << "Invalid document in " << __PRETTY_FUNCTION__ << std::endl;    // FIXME: warn the user somehow?    doc.reset ();  } else {    for (xmlNodePtr child = doc_root->children;	 child != NULL;	 child = child->next)      if (child->type == XML_ELEMENT_NODE	  && child->name != NULL	  && xmlStrEqual (BAD_CAST ("list"), child->name)) {	parse_list (child);	break; // read only one!      }  }}

static xmlNodePtr analyze_board(Board *b){    xmlNodePtr anaNode;    anaNode = xmlNewNode(NULL, BAD_CAST("analysis"));    (void)b; /* TODO */    return anaNode;}

libvisio::VSDXRelationships::VSDXRelationships(librevenge::RVNGInputStream *input)  : m_relsByType(), m_relsById(){  if (input)  {    const std::shared_ptr<xmlTextReader> reader(      xmlReaderForStream(input, nullptr, nullptr, XML_PARSE_NOBLANKS|XML_PARSE_NOENT|XML_PARSE_NONET|XML_PARSE_RECOVER),      xmlFreeTextReader);    if (reader)    {      bool inRelationships = false;      int ret = xmlTextReaderRead(reader.get());      while (ret == 1)      {        const xmlChar *name = xmlTextReaderConstName(reader.get());        if (name)        {          if (xmlStrEqual(name, BAD_CAST("Relationships")))          {            if (xmlTextReaderNodeType(reader.get()) == 1)            {              // VSD_DEBUG_MSG(("Relationships ON/n"));              inRelationships = true;            }            else if (xmlTextReaderNodeType(reader.get()) == 15)            {              // VSD_DEBUG_MSG(("Relationships OFF/n"));              inRelationships = false;            }          }          else if (xmlStrEqual(name, BAD_CAST("Relationship")))          {            if (inRelationships)            {              VSDXRelationship relationship(reader.get());              m_relsByType[relationship.getType()] = relationship;              m_relsById[relationship.getId()] = relationship;            }          }        }        ret = xmlTextReaderRead(reader.get());      }    }  }}

xmlXPathObjectPtr evalXPath(xmlXPathContextPtr context, const gchar *xpath) {  xmlXPathObjectPtr result = xmlXPathEvalExpression(BAD_CAST(xpath), context);  if(result == NULL) {    g_warning("xmlXPathEvalExpression '%s' failed!/n", xpath);    exit(1);  }  return result;}

xml_doc_info * SACONFIG_API xml_CreateDoc(char const * const xml_root, char const * const xml_base){	xml_doc_info * docinfo = NULL;	xmlDocPtr doc = NULL;	xmlNodePtr curNode = NULL;	xmlInitParser();	doc = xmlNewDoc(BAD_CAST("1.0"));	curNode = xmlNewNode(NULL, BAD_CAST(xml_root));	xmlDocSetRootElement(doc, curNode);	curNode = xmlNewChild(curNode, NULL, BAD_CAST(xml_base), NULL);	docinfo = (xml_doc_info *)malloc(sizeof(xml_doc_info));	memset(docinfo, 0, sizeof(xml_doc_info));	docinfo->isInitParser = true;	docinfo->doc = doc;	strcpy(docinfo->xml_root, xml_root);	strcpy(docinfo->xml_base, xml_base);	return docinfo;}

xmlNodePtr Lua::ConvertToXML( lua_State *L, int value_index, int key_index) {    int t;    char buff[1024];    xmlNodePtr section = xmlNewNode(NULL, BAD_CAST "value");    // Using lua_tostring will convert a value into a string.    // Never use this on a table key.    lua_pushvalue(L, key_index);    t = lua_type(L, key_index);    // Save the Key and keytype    xmlSetProp( section, BAD_CAST "key", BAD_CAST lua_tostring(L, lua_gettop(L)) );    xmlSetProp( section, BAD_CAST "keytype", BAD_CAST lua_typename(L, t));    lua_pop(L,1); // Pop the copied key now that we're done with it.    // Save the type    t = lua_type(L, value_index);    xmlSetProp( section, BAD_CAST "type", BAD_CAST lua_typename(L, t));    // Save the value    switch (t) {    case LUA_TBOOLEAN:        xmlNodeSetContent( section, BAD_CAST (lua_toboolean(L, value_index) ? "true" : "false"));        break;    case LUA_TNUMBER:        snprintf(buff, sizeof(buff), "%f", lua_tonumber(L, value_index) );        xmlNodeSetContent( section, BAD_CAST buff);        break;    case LUA_TSTRING:        xmlNodeSetContent( section, BAD_CAST lua_tostring(L, value_index) );        break;    case LUA_TTABLE:        lua_pushnil(L);        while(lua_next(L, value_index)) {            xmlAddChild( section, Lua::ConvertToXML(L, lua_gettop(L), lua_gettop(L)-1));            // Pop off this value            lua_pop(L, 1);        }        break;    case LUA_TNIL:    case LUA_TLIGHTUSERDATA:    case LUA_TFUNCTION:    case LUA_TUSERDATA:    case LUA_TTHREAD:        xmlAddChild( section, xmlNewComment( BAD_CAST "Cannot convert to XML"));        break;    default:        assert(0);        break;    }    return section;}

int getsempkey(void* lpxmlDoc,int* lpResult){    xmlDocPtr		 pxmlDoc;    xmlNodePtr		 cur;    xmlNodePtr		 curpath;    xmlXPathContextPtr	 context = NULL;    xmlXPathObjectPtr	 result	 = NULL;    xmlNodeSetPtr	 nodeset;    xmlAttrPtr		 attrPtr;    xmlChar		*key;    xmlChar		*xpath	 = BAD_CAST("/application/semkey");            pxmlDoc = (xmlDocPtr)lpxmlDoc;        cur = xmlDocGetRootElement(pxmlDoc);    if (cur == NULL)    {        printf("Can't get the root element/n");        return 0;    }    context = xmlXPathNewContext(pxmlDoc);    result  = xmlXPathEvalExpression(xpath, context);    xmlXPathFreeContext(context);               if (result != NULL)    {	 if (xmlXPathNodeSetIsEmpty(result->nodesetval) == 0)	 {	      nodeset = result->nodesetval;	      if(nodeset->nodeNr > 0)	      {		   curpath = nodeset->nodeTab[0];		   if(curpath != NULL)		   {			attrPtr = curpath->properties;			while (attrPtr != NULL)			{			    if (!xmlStrcmp(attrPtr->name, BAD_CAST "value"))			    {				 key = xmlGetProp(curpath,(const xmlChar *)"value");				 printf("semid: %s/n", key);				 *lpResult = atoi((char*)key);				 xmlFree(key);			    }			    attrPtr = attrPtr->next;		       }		  }	       	      }	 } 	xmlXPathFreeObject(result);    }    return 0;}

/**/brief Converts the Model to an XML node. */xmlNodePtr Model::ToXMLNode(string componentName) {	char buff[256];    xmlNodePtr section = xmlNewNode(NULL, BAD_CAST componentName.c_str());	xmlNewChild(section, NULL, BAD_CAST "name", BAD_CAST this->GetName().c_str() );	xmlNewChild(section, NULL, BAD_CAST "description", BAD_CAST this->GetDescription().c_str() );	xmlNewChild(section, NULL, BAD_CAST "image", BAD_CAST this->GetImage()->GetPath().c_str() );	xmlNewChild(section, NULL, BAD_CAST "engine", BAD_CAST this->GetDefaultEngine()->GetName().c_str() );	snprintf(buff, sizeof(buff), "%1.2f", this->GetMass() );	xmlNewChild(section, NULL, BAD_CAST "mass", BAD_CAST buff );	snprintf(buff, sizeof(buff), "%1.2f", this->GetRotationsPerSecond() );	xmlNewChild(section, NULL, BAD_CAST "rotationsPerSecond", BAD_CAST buff );	snprintf(buff, sizeof(buff), "%d", this->GetThrustOffset() );	xmlNewChild(section, NULL, BAD_CAST "thrustOffset", BAD_CAST buff );	snprintf(buff, sizeof(buff), "%1.1f", this->GetMaxSpeed() );	xmlNewChild(section, NULL, BAD_CAST "maxSpeed", BAD_CAST buff );	snprintf(buff, sizeof(buff), "%d", this->GetHullStrength() );	xmlNewChild(section, NULL, BAD_CAST "hullStrength", BAD_CAST buff );	snprintf(buff, sizeof(buff), "%d", this->GetShieldStrength() );	xmlNewChild(section, NULL, BAD_CAST "shieldStrength", BAD_CAST buff );	snprintf(buff, sizeof(buff), "%d", this->GetMSRP() );	xmlNewChild(section, NULL, BAD_CAST "msrp", BAD_CAST buff );	snprintf(buff, sizeof(buff), "%d", this->GetCargoSpace() );	xmlNewChild(section, NULL, BAD_CAST "cargoSpace", BAD_CAST buff );	char *ntos = (char*)malloc(256);	xmlNodePtr wsPtr = xmlNewNode(NULL, BAD_CAST "weaponSlots");	for(unsigned int w=0;w<weaponSlots.size();w++){		WeaponSlot *slot = &weaponSlots[w];		xmlNodePtr slotPtr = xmlNewNode(NULL, BAD_CAST "slot");		xmlNewChild(slotPtr, NULL, BAD_CAST "name", BAD_CAST slot->name.c_str() );		xmlNodePtr coordPtr = xmlNewNode(NULL, BAD_CAST "coord");		snprintf(ntos, 256, "%d", slot->x);		xmlNewChild(coordPtr, NULL, BAD_CAST "x", BAD_CAST ntos);		snprintf(ntos, 256, "%d", slot->y);		xmlNewChild(coordPtr, NULL, BAD_CAST "y", BAD_CAST ntos);		xmlAddChild(slotPtr, coordPtr);		snprintf(ntos, 256, "%.1f", slot->angle);		xmlNewChild(slotPtr, NULL, BAD_CAST "angle", BAD_CAST ntos);		snprintf(ntos, 256, "%.1f", slot->motionAngle);		xmlNewChild(slotPtr, NULL, BAD_CAST "motionAngle", BAD_CAST ntos);		xmlNewChild(slotPtr, NULL, BAD_CAST "content", BAD_CAST ((slot->content == NULL)		                                             ? ""		                                             : slot->content->GetName().c_str()) );		snprintf(ntos, 256, "%d", slot->firingGroup);		xmlNewChild(slotPtr, NULL, BAD_CAST "firingGroup", BAD_CAST ntos);		xmlAddChild(wsPtr, slotPtr);	}	xmlAddChild(section, wsPtr);	free(ntos);	return section;}

libvisio::VSDXRelationship::VSDXRelationship(xmlTextReaderPtr reader)  : m_id(), m_type(), m_target(){  if (reader)    // TODO: check whether we are actually parsing "Relationship" element  {    while (xmlTextReaderMoveToNextAttribute(reader))    {      const xmlChar *name = xmlTextReaderConstName(reader);      const xmlChar *value = xmlTextReaderConstValue(reader);      if (xmlStrEqual(name, BAD_CAST("Id")))        m_id = (const char *)value;      else if (xmlStrEqual(name, BAD_CAST("Type")))        m_type = (const char *)value;      else if (xmlStrEqual(name, BAD_CAST("Target")))        m_target = (const char *)value;    }    // VSD_DEBUG_MSG(("Relationship : %s type: %s target: %s/n", m_id.c_str(), m_type.c_str(), m_target.c_str()));  }}