// below added for xml merge // removes spaces between # and the text static 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 gboolean command_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 CXMLElement truecopy - if true this is set to point to element of telement, otherwise this is set to point to a copy of element in telement output: 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); }
void XMLNodeList::insertAtBeginning(const XMLElement & elem) { xmlNode *cpy = xmlCopyNode(elem.getRealNode(), 1); xmlUnlinkNode(cpy); scope->unregisterNodeListPointer(parent->children); xmlAddPrevSibling(parent->children, cpy); scope->registerPointers(parent->children, this); size++; }
// 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 Document::copyNodes(const NodeList& nodeList) { if (!isValid() || _xmlDoc->children == NULL) { return; // is not Valid, place an assertion here? } // Copy the child nodes one by one for (std::size_t i = 0; i < nodeList.size(); i++) { // Copy the node xmlNodePtr node = xmlCopyNode(nodeList[i].getNodePtr(), 1); // Add this node to the top level node of this document xmlAddChild(xmlDocGetRootElement(_xmlDoc), node); } }
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); } }
void XMLElement::append(const XMLElement & elem) const { XMLNodeList * list = 0; xmlNode *cpy = xmlCopyNode(elem.getRealNode(), 1); xmlUnlinkNode(cpy); xmlAddChild(node, cpy); list = scope->getXMLNodeListFromLibXMLPtr(node->children); if (list) { list->incrementSize(); } }
void XMLNodeList::insertAtIndex(int index, const XMLElement & elem) { xmlNode *n = getListNode(index); if (n) { xmlNode *cpy = xmlCopyNode(elem.getRealNode(), 1); xmlUnlinkNode(cpy); xmlAddNextSibling(n, cpy); size++; } }
/* * 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; }