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

// below added for xml merge// removes spaces between # and the textstatic int modifytree(xmlNodePtr* ParentPtr, xmlNodePtr sourceNode){	int notfound = -1; //not found	xmlNodePtr child = (*ParentPtr)->xmlChildrenNode, txt = NULL;	while (child != NULL)	{		if ((xmlStrcmp(child->name, (const xmlChar*)"text")))		{			if ((!xmlStrcmp(child->name, sourceNode->name)))			{				xmlNodePtr destNode = xmlCopyNode(sourceNode, 1);				xmlNodePtr old = xmlReplaceNode(child, destNode);				xmlFreeNode(old);				notfound = 0;				break;			}		}		else		{			txt = child;		}		child = child->next;	}	if (notfound == -1)	{		xmlAddChild(*ParentPtr, xmlCopyNode(sourceNode, 1));		xmlAddChild(*ParentPtr, xmlCopyNode(txt, 1));		logger_remotem("LOAD_CONFIG_FILE: Node not found, adding new node: %s", sourceNode->name);	}	return notfound;}

  bool WaveFunctionFactory::build(xmlNodePtr cur, bool buildtree) {    if(cur == NULL) return false;    bool attach2Node=false;    if(buildtree) {      if(myNode == NULL) {        myNode = xmlCopyNode(cur,1);      } else {        attach2Node=true;      }    }    if(targetPsi==0) {//allocate targetPsi and set the name      targetPsi  = new TrialWaveFunction;      targetPsi->setName(myName);      app_log() << "  Creating a trial wavefunction " << myName << endl;    }    cur = cur->children;    bool success=true;    while(cur != NULL) {      string cname((const char*)(cur->name));      if (cname == OrbitalBuilderBase::detset_tag)       {        success = addFermionTerm(cur);      }       else if (cname ==  OrbitalBuilderBase::jastrow_tag)       {        OrbitalBuilderBase *jbuilder = new JastrowBuilder(*targetPtcl,*targetPsi,ptclPool);        success = jbuilder->put(cur);        addNode(jbuilder,cur);      }      else if(cname == "agp")       {#if defined(QMC_COMPLEX)        app_error() << "  AGPDeterminant cannot be used with QMC_COMPLEX=1" << endl;        return false;#else        AGPDeterminantBuilder* agpbuilder = new AGPDeterminantBuilder(*targetPtcl,*targetPsi,ptclPool);        success = agpbuilder->put(cur);        addNode(agpbuilder,cur);#endif      }       if(attach2Node) xmlAddChild(myNode,xmlCopyNode(cur,1));      cur = cur->next;    }    if(OrbitalBuilderBase::print_level>0)    {      app_log() << "  List of optimizable variables " << endl;      targetPsi->VarList.print(app_log());      //set to zero so that nothing is written again      OrbitalBuilderBase::print_level=0;    }    return success;  }

void c_XSLTProcessor::t_importstylesheet(const Object& stylesheet) {  xmlDocPtr doc = nullptr;  if (stylesheet.instanceof(c_DOMDocument::classof())) {    c_DOMDocument *domdoc = stylesheet.getTyped<c_DOMDocument>();    // This doc will be freed by xsltFreeStylesheet.    doc = xmlCopyDoc((xmlDocPtr)domdoc->m_node, /*recursive*/ 1);    if (doc == nullptr) {      raise_error("Unable to import stylesheet");    }  } else if (stylesheet.instanceof(c_SimpleXMLElement::classof())) {    c_SimpleXMLElement *elem = stylesheet.getTyped<c_SimpleXMLElement>();    // This doc will be freed by xsltFreeStylesheet.    doc = xmlNewDoc((const xmlChar*)"1.0");    xmlNodePtr node = xmlCopyNode(elem->node, /*extended*/ 1);    if (doc == nullptr || node == nullptr) {      raise_error("Unable to import stylesheet");    }    xmlDocSetRootElement(doc, node);  } else {    raise_error("Object must be an instance of DOMDocument or "                "SimpleXMLElement");  }  if (doc) {    m_stylesheet = xsltParseStylesheetDoc(doc);    if (m_stylesheet == nullptr) {      raise_error("Unable to import stylesheet");    }  }}

HRESULT node_clone(xmlnode *This, VARIANT_BOOL deep, IXMLDOMNode **cloneNode){    IXMLDOMNode *node;    xmlNodePtr clone;    if(!cloneNode) return E_INVALIDARG;    clone = xmlCopyNode(This->node, deep ? 1 : 2);    if (clone)    {        xmlSetTreeDoc(clone, This->node->doc);        xmldoc_add_orphan(clone->doc, clone);        node = create_node(clone);        if (!node)        {            ERR("Copy failed/n");            xmldoc_remove_orphan(clone->doc, clone);            xmlFreeNode(clone);            return E_FAIL;        }        *cloneNode = node;    }    else    {        ERR("Copy failed/n");        return E_FAIL;    }    return S_OK;}

/* * COMMAND: <gda_report_section> * * Creates copies of its contents, one copy per row in the new run context's * data model. * * uses node's contents: yes * requested attributes: none * * REM: either "query_name" or a <gda_report_query> sub node must be provided to create a data model. */static gbooleancommand_gda_report_iter_run (GdaReportEngine *engine, xmlNodePtr node, GSList **created_nodes,			     RunContext *context, GError **error){	if (!context || !context->iter)		return TRUE;	gda_data_model_iter_move_next (context->iter);	while (gda_data_model_iter_is_valid (context->iter)) {		xmlNodePtr dup, child;		dup = xmlCopyNode (node, 1);						if (!real_run_at_node (engine, dup->children, context, error)) {			xmlFreeNode (dup);			return FALSE;		}		else {			for (child = dup->children; child; child = dup->children) {				xmlUnlinkNode (child);				*created_nodes = g_slist_prepend (*created_nodes, child);			}		}		xmlFreeNode (dup);		gda_data_model_iter_move_next (context->iter);	}	*created_nodes = g_slist_reverse (*created_nodes);	return TRUE;}

static xmlNode *get_sub_node (xmlDoc *doc){  xmlNode *node;  xmlXPathContext *xpath_ctx;  xmlXPathObject * xpath_obj;  xpath_ctx = xmlXPathNewContext (doc);  xpath_obj = xmlXPathEvalExpression ((xmlChar *) "/osm/node|/osm/way|/osm/relation",                                      xpath_ctx);  if (xpath_obj && xpath_obj->nodesetval && xpath_obj->nodesetval->nodeNr > 0)    {      node = xmlCopyNode (xpath_obj->nodesetval->nodeTab[0], 1);    }  else    {      g_warning ("Couldn't find element");      node = NULL;    }  xmlXPathFreeObject (xpath_obj);  xmlXPathFreeContext (xpath_ctx);  return node;}

/**/brief Convert an XML node from the old saved-games.xml format to the new format. * /details *   The old saved-games.xml format put all of the Player information in one file. *   The new saved-games.xml format only stores some Player information, but *   nothing that relies on loading the Simulation.  Everything in the old *   style format is by itself in a standalone xml file named after the player. * /todo This could save a copy of the old saved-games.xml to a backup location. * /param[in] doc The XML document. * /param[in] xnode The XML Node. * /return A new XML node that represents the PlayerInfo for the Player. */xmlNodePtr PlayerInfo::ConvertOldVersion( xmlDocPtr doc, xmlNodePtr node ) {	char buff[256];	xmlDocPtr xmlPtr;	xmlNodePtr  attr;	xmlNodePtr  copy = xmlCopyNode( node, 1);	string filename = "Resources/Definitions/"+ name +".xml";	LogMsg(INFO, "Converting %s to an xml file: %s ", name.c_str(), filename.c_str() );	xmlPtr = xmlNewDoc( BAD_CAST "1.0" );	xmlDocSetRootElement(xmlPtr, copy);	// Version information	snprintf(buff, sizeof(buff), "%d", EPIAR_VERSION_MAJOR);	xmlNewChild(copy, NULL, BAD_CAST "version-major", BAD_CAST buff);	snprintf(buff, sizeof(buff), "%d", EPIAR_VERSION_MINOR);	xmlNewChild(copy, NULL, BAD_CAST "version-minor", BAD_CAST buff);	snprintf(buff, sizeof(buff), "%d", EPIAR_VERSION_MICRO);	xmlNewChild(copy, NULL, BAD_CAST "version-macro", BAD_CAST buff);	xmlSaveFormatFileEnc( filename.c_str(), xmlPtr, "ISO-8859-1", 1);	xmlNodePtr new_node = xmlNewNode(NULL, BAD_CAST "player");	xmlNewChild(new_node, NULL, BAD_CAST "name", BAD_CAST GetName().c_str() );	xmlNewChild(new_node, NULL, BAD_CAST "file", BAD_CAST filename.c_str() );	if( (attr = FirstChildNamed(copy, "lastLoadTime")) ){		xmlNewChild(new_node, NULL, BAD_CAST "lastLoadTime", BAD_CAST NodeToString(doc,attr).c_str() );	}		return new_node;}

XmlNode& XmlNode::operator =(const XmlNode& n){	if (m_hXml)		xmlDestroyNode(m_hXml);	m_hXml = xmlCopyNode(n);	return *this;}

    /// get XML from current object    FWXML_API xmlNodePtr getXMLFrom( ::fwData::Object::sptr obj )    {        OSLM_DEBUG("GenericXMLTranslator for " << obj->className() << "-" <<  obj.get() );        // check obj is well realated to RealObject        ::boost::shared_ptr<RealData> robj = ::boost::dynamic_pointer_cast<RealData >(obj);        SLM_ASSERT("robj not instanced", robj);        // create master node with className+id        xmlNodePtr node = XMLTranslatorHelper::MasterNode( robj );        // create data information using boost tweaked archive        ::boost::archive::fw_xml_oarchive ao_xml(0);        {            ao_xml.operator&( ::boost::serialization::make_nvp("BoostManagedObject", *robj ) ); // Serialization with pointer generate an NVP (.first with NULL name !!!)        }        xmlNodePtr boostXML =  ao_xml.getXMLNode();        SLM_ASSERT("boostXML not instanced", boostXML);        boostXML = boostXML->children;        while ( boostXML!=NULL )        {            if ( boostXML->type == XML_ELEMENT_NODE )            {                xmlAddChild( node, xmlCopyNode(boostXML,1) );            }            boostXML =  boostXML->next;        }        xmlFree( ao_xml.getXMLNode() );        return node;    }

/*CopyElement - copies element of other CXMLElementtruecopy - if true this is set to point to element of telement, otherwise this is set to point to a copy of element in telementoutput: telement - xml element to copy from*/void CXMLElement::CopyElement(CXMLElement *telement,Bool truecopy){	if (truecopy)		element = xmlCopyNode(telement->GetNodePtr(), 1);	else		element = telement->GetNodePtr();}

xmlNodePtr design_tolerance_to_xml_node(design_tolerance_s *t){  xmlNodePtr n = NULL;  xmlNodePtr vn = NULL;  char sn[MAX_SN];    // Sanity check parameters.  assert(t);  n = xmlNewNode(NULL, BAD_CAST "tolerance");  if (!n) return NULL;  vn = vertex_to_xml_node(t->location);  if (vn)  {    xmlAddChild(n, xmlCopyNode(vn, 1));    xmlFreeNode(vn);  }  snprintf(sn, MAX_SN, "%f", t->text_size);  xmlNewChild(n, NULL, BAD_CAST "text-size", BAD_CAST sn);  snprintf(sn, MAX_SN, "%f", t->plus);  xmlNewChild(n, NULL, BAD_CAST "plus", BAD_CAST sn);  snprintf(sn, MAX_SN, "%f", t->minus);  xmlNewChild(n, NULL, BAD_CAST "minus", BAD_CAST sn);  snprintf(sn, MAX_SN, "%d", t->precision);  xmlNewChild(n, NULL, BAD_CAST "precision", BAD_CAST sn);    // Return RETVAL  return n;}

    void XMLNodeList::replaceAtIndex(int index, const XMLElement & elem)    {        xmlNode *n = getListNode(index);        if (n && n != elem.getRealNode())        {            if (index == 1)            {                scope->unregisterNodeListPointer(parent->children);            }            xmlNode *previous = n->prev;            xmlNode *next = n->next;            xmlNode *cpy = xmlCopyNode(elem.getRealNode(), 1);            xmlUnlinkNode(cpy);            xmlReplaceNode(n, cpy);            xmlFreeNode(n);            prevNode = cpy;            cpy->prev = previous;            cpy->next = next;            if (index == 1)            {                scope->registerPointers(parent->children, this);            }        }    }

    void XMLNodeList::insertAtEnd(const XMLElement & elem)    {        xmlNode *cpy = xmlCopyNode(elem.getRealNode(), 1);        xmlUnlinkNode(cpy);        xmlAddChild(parent, cpy);        size++;    }

// Inherits XMLSpy generation source function.xmlNodePtr CNode::InternalInsertNodeAt(const tstring& sNamespaceURI, const tstring& sName, int nIndex, CNode& rNode){	rNode.m_pDOMNode = xmlAddPrevSibling(			InternalGetAt(Element, sNamespaceURI, sName, nIndex),			xmlCopyNode(rNode.m_pDOMNode, 1)			);	return rNode.m_pDOMNode;}

Extension::Extension( ::boost::shared_ptr< Bundle > bundle, const std::string & id, const std::string & point, xmlNodePtr xmlNode ): BundleElement ( bundle                    ),  m_id          ( id                        ),  m_point       ( point                     ),  m_xmlDoc      ( xmlNewDoc(BAD_CAST "1.0") ),  m_xmlNode     ( xmlCopyNode(xmlNode, 1)   ),  m_validity    ( UnknownValidity           ){    xmlDocSetRootElement(m_xmlDoc, m_xmlNode);}

// Inherits XMLSpy generation source function.xmlNodePtr CNode::InternalReplaceNodeAt(const tstring& sNamespaceURI, const tstring& sName, int nIndex, CNode& rNode){	xmlNodePtr pOldNode = rNode.m_pDOMNode;	rNode.m_pDOMNode = xmlReplaceNode(			InternalGetAt(Element, sNamespaceURI, sName, nIndex),			xmlCopyNode(rNode.m_pDOMNode, 1)			);	CDoc::ReleaseFragment(pOldNode);	return rNode.m_pDOMNode;}

xmlNodePtr CSpmXml::Clone(xmlNodePtr pNode, bool bDeep){	pNode = GetNode(pNode);	if (0 == pNode)		return 0;	int nRecursive = 1;	if (!bDeep)		nRecursive = 2;	return xmlCopyNode(pNode, nRecursive);}

xmlNode *oscap_xmlstr_to_dom(xmlNode *parent, const char *elname, const char *content){	char *str = oscap_sprintf("<x xmlns:xhtml='http://www.w3.org/1999/xhtml'>%s</x>", content);	xmlDoc *doc = xmlReadMemory(str, strlen(str), NULL, NULL,		XML_PARSE_RECOVER | XML_PARSE_NOERROR | XML_PARSE_NOWARNING | XML_PARSE_NONET | XML_PARSE_NSCLEAN);	xmlNode *text_node = xmlCopyNode(xmlDocGetRootElement(doc), 1);	xmlNodeSetName(text_node, BAD_CAST elname);	xmlAddChild(parent, text_node);	xmlFreeDoc(doc);	oscap_free(str);	return text_node;}

//USAGEMODE HRESULT TS_hGetConfigurationData(BYTE*& pDesBuffer, UINT& nBuffSize)USAGEMODE HRESULT TS_hGetConfigurationData(xmlNodePtr* pxmlNodePtr){    if(g_pomTSExecutorChildWindow != NULL)    {        return g_pomTSExecutorChildWindow->GetConfigurationData(*pxmlNodePtr);    }    else    {        *pxmlNodePtr = xmlCopyNode(m_pXmlConfigNode, 1);        return S_OK;    }}

void XMLElement::setChildren(const XMLElement & elem) const{    xmlNode *n = elem.getRealNode();    if (n && n->parent != node)    {        xmlNode *cpy = xmlCopyNode(n, 1);        xmlUnlinkNode(cpy);        xmlUnlinkNode(node->children);        xmlFreeNodeList(node->children);        node->children = 0;        xmlAddChild(node, cpy);    }}

/* * call-seq: *  dup * * Copy this node */static VALUE duplicate_node(VALUE self){  xmlNodePtr node, dup;  Data_Get_Struct(self, xmlNode, node);  dup = xmlCopyNode(node, 1);  if(dup == NULL) return Qnil;  dup->doc = node->doc;  assert(node->parent);  xmlAddChild(node->parent, dup);  return Nokogiri_wrap_xml_node(dup);}

std::string XMLParser::toString(xmlNodePtr node){    SLM_ASSERT("node not instanced", node);    xmlDocPtr doc = xmlNewDoc(BAD_CAST "1.0");    xmlDocSetRootElement ( doc , xmlCopyNode( node, 1 ) );    std::stringstream ss;    XMLStream::toStream( doc, ss );    // cleaning    xmlFreeDoc( doc );    return ss.str();}

xml_node_t * xml_node_from_buf(struct xml_node_ctx *ctx, const char *buf){	xmlDocPtr doc;	xmlNodePtr node;	doc = xmlParseMemory(buf, strlen(buf));	if (doc == NULL)		return NULL;	node = xmlDocGetRootElement(doc);	node = xmlCopyNode(node, 1);	xmlFreeDoc(doc);	return (xml_node_t *) node;}

/** * gda_report_engine_run_as_node * @engine: a #GdaReportEngine object * @error: a place to store errors, or %NULL * * Execute the @engine engine and creates a new xmlNodePtr XML node * * Returns: a new xmlNodePtr or %NULL if an error occurred */xmlNodePtr gda_report_engine_run_as_node (GdaReportEngine *engine, GError **error){	xmlNodePtr retnode;	g_return_val_if_fail (GDA_IS_REPORT_ENGINE (engine), NULL);	g_return_val_if_fail (engine->priv, NULL);	g_return_val_if_fail (engine->priv->spec, NULL);	retnode = xmlCopyNode (engine->priv->spec, 1);	if (!real_run_at_node (engine, retnode, NULL, error)) {		xmlFreeNode (retnode);		retnode = NULL;	}	return retnode;}

    XMLNode::NodeData * XMLNode::NodeData::detachingClone(){      --m_invRefCount;      NodeData *_data = new NodeData;      //copy      _data->m_content = m_content;      _data->m_name = m_name;      _data->m_attributes = m_attributes;      _data->m_childNodes = m_childNodes;      _data->m_node = xmlCopyNode( m_node,  2 );          return _data;    }

xmlNodePtr GetXmlNodePtrFromString( const string& xml_string ) {		xmlNodePtr root_node = 0;	Xml::DocPtr doc_( xmlParseDoc( BAD_CAST xml_string.c_str() ) );	if ( doc_ ) {		root_node = xmlDocGetRootElement( doc_ );    }		if ( root_node )	{		return xmlCopyNode( root_node, 1 );    }	return 0;}