bool CXMLElement::MoveElement(CXMLElement* p_element, bool p_sibling, bool p_before) { xmlNodePtr t_parent; for(t_parent = element; t_parent != NULL; t_parent = t_parent -> parent) if (t_parent == p_element -> GetNodePtr()) return false; xmlUnlinkNode(p_element -> GetNodePtr()); if (p_sibling) { if (p_before) xmlAddPrevSibling(element, p_element -> GetNodePtr()); else xmlAddNextSibling(element, p_element -> GetNodePtr()); } else { if (p_before && element -> children != NULL) xmlAddPrevSibling(element -> children, p_element -> GetNodePtr()); else xmlAddChild(element, p_element -> GetNodePtr()); } return true; }
/** * Creates a new element node and sets it as the root element. This will * only work if the document is empty; otherwise EDocumentNotEmpty is thrown. */ ElementNode* Document::createRootElement(const char *pcszRootElementName, const char *pcszComment /* = NULL */) { if (m->pRootElement || m->plibDocument) throw EDocumentNotEmpty(RT_SRC_POS); // libxml side: create document, create root node m->plibDocument = xmlNewDoc((const xmlChar*)"1.0"); xmlNode *plibRootNode; if (!(plibRootNode = xmlNewNode(NULL, // namespace (const xmlChar*)pcszRootElementName))) throw std::bad_alloc(); xmlDocSetRootElement(m->plibDocument, plibRootNode); // now wrap this in C++ m->pRootElement = new ElementNode(NULL, NULL, plibRootNode); // add document global comment if specified if (pcszComment != NULL) { xmlNode *pComment; if (!(pComment = xmlNewDocComment(m->plibDocument, (const xmlChar *)pcszComment))) throw std::bad_alloc(); xmlAddPrevSibling(plibRootNode, pComment); // now wrap this in C++ m->pComment = new ElementNode(NULL, NULL, pComment); } return m->pRootElement; }
XMLNode XMLNode::NewChild(const XMLNode& node, int n, bool global_order) { if (node_ == NULL) return XMLNode(); if (node.node_ == NULL) return XMLNode(); if (node_->type != XML_ELEMENT_NODE) return XMLNode(); // TODO: Add new attribute if 'node' is attribute if (node.node_->type != XML_ELEMENT_NODE) return XMLNode(); xmlNodePtr new_node = xmlDocCopyNode(node.node_, node_->doc, 1); if (new_node == NULL) return XMLNode(); if (n < 0) return XMLNode(xmlAddChild(node_, new_node)); std::string name; xmlNsPtr ns = GetNamespace(new_node); if (ns != NULL) { if (ns->prefix != NULL) name = (char*)ns->prefix; name += ":"; } if (new_node->name) name += (char*)(new_node->name); XMLNode old_node = global_order ? Child(n) : operator[](name)[n]; if (!old_node) // TODO: find last old_node return XMLNode(xmlAddChild(node_, new_node)); if (old_node) return XMLNode(xmlAddPrevSibling(old_node.node_, new_node)); return XMLNode(xmlAddChild(node_, new_node)); }
XMLNode XMLNode::NewChild(const char *name, int n, bool global_order) { if (node_ == NULL) return XMLNode(); if (node_->type != XML_ELEMENT_NODE) return XMLNode(); const char *name_ = strchr(name, ':'); xmlNsPtr ns = NULL; if (name_ != NULL) { std::string ns_(name, name_ - name); ns = xmlSearchNs(node_->doc, node_, (const xmlChar*)(ns_.c_str())); ++name_; } else name_ = name; xmlNodePtr new_node = xmlNewNode(ns, (const xmlChar*)name_); if (new_node == NULL) return XMLNode(); if (n < 0) return XMLNode(xmlAddChild(node_, new_node)); XMLNode old_node = global_order ? Child(n) : operator[](name)[n]; if (!old_node) // TODO: find last old_node return XMLNode(xmlAddChild(node_, new_node)); if (old_node) return XMLNode(xmlAddPrevSibling(old_node.node_, new_node)); return XMLNode(xmlAddChild(node_, new_node)); }
xmlNode* child_node_list::insert_(iterator pos, xmlNode* child) { // Check the ownership of the iterator parameter. check_ownership_(pos); // Unlink the child node from its previous owner. xmlUnlinkNode(child); // Insert the libxml2 node to this child node list. xmlNode* px = 0; if (pos == end()) { px = xmlAddChild(raw_, child); } else { px = xmlAddPrevSibling(pos->raw(), child); } if (px == 0) { std::string what = "fail to insert: xmlAddChild()/xmlAddPrevSibling() returned null"; throw internal_dom_error(what); } // Reconciliate XML namespaces as necessary. if (px->type == XML_ELEMENT_NODE) { int count = xmlReconciliateNs(px->doc, px); if (count < 0) { throw internal_dom_error("fail to reconciliate xmlns on the inserted element"); } } // Return the inserted libxml2 node. return px; }
WsXmlNodeH xml_parser_node_add(WsXmlNodeH base, int where, const char *nsUri, const char *localName, const char *value, int xmlescape) { xmlNodePtr xmlBase = (xmlNodePtr) base; xmlNodePtr newNode = make_new_xml_node((where != XML_ELEMENT_NEXT && where != XML_ELEMENT_PREV) ? xmlBase : xmlBase->parent, nsUri, localName, value, xmlescape); if (newNode) { switch (where) { case XML_ELEMENT_NEXT: xmlAddNextSibling((xmlNodePtr) base, newNode); break; case XML_ELEMENT_PREV: xmlAddPrevSibling((xmlNodePtr) base, newNode); break; case XML_LAST_CHILD: default: xmlAddChild((xmlNodePtr) base, newNode); break; } } return (WsXmlNodeH) newNode; }
Bool CXMLDocument::AddDTD(char *data, unsigned long tlength) { if (!isinited()) return False; xmlParserInputBufferPtr dtdInputBufferPtr; xmlDtdPtr dtd; dtdInputBufferPtr = xmlParserInputBufferCreateMem(data, tlength, XML_CHAR_ENCODING_UTF8); dtd = xmlIOParseDTD(NULL, dtdInputBufferPtr, XML_CHAR_ENCODING_UTF8); if (!dtd) return False; if (dtd->name != NULL) xmlFree((char*)dtd->name); CXMLElement telement; GetRootElement(&telement); dtd->name = xmlStrdup((xmlChar *)telement.GetName()); doc->intSubset = dtd; if (dtd->ExternalID != NULL) { xmlFree((xmlChar *) dtd->ExternalID); dtd->ExternalID = NULL; } if (dtd->SystemID != NULL) { xmlFree((xmlChar *) dtd->SystemID); dtd->SystemID = NULL; } dtd->doc = doc; dtd->parent = doc; if (doc->children == NULL) xmlAddChild((xmlNodePtr)doc, (xmlNodePtr)dtd); else xmlAddPrevSibling(doc->children, (xmlNodePtr)dtd); return Validate(); }
/* * Interprets nodes from @topnode and for all of @topnode's next siblings */ static gboolean real_run_at_node (GdaReportEngine *engine, xmlNodePtr topnode, RunContext *context, GError **error) { xmlNodePtr node; xmlNodePtr next_node = NULL; for (node = topnode; node; node = next_node) { next_node = node->next; if (!strncmp ((gchar *) node->name, "gda_report", 10)) { GSList *created_nodes = NULL; gboolean cmd_res = TRUE; gsize i; gboolean command_found = FALSE; for (i = 0; i < sizeof (commands) / sizeof (EngineCommand); i++) { EngineCommand *ec = (EngineCommand *) &(commands [i]); if (ec->has_prefix) { if (!strcmp (((gchar *) node->name) + 10, ec->tag_name + 10)) { command_found = TRUE; if (ec->func) cmd_res = (ec->func) (engine, node, &created_nodes, context, error); break; } } } if (!command_found) { /* gda_ node not implemented */ TO_IMPLEMENT; g_warning ("Engine command '%s' is not yet implemented", (gchar *) node->name); } if (created_nodes) { /* put @node's contents before @node */ GSList *list; for (list = created_nodes; list; list = list->next) { next_node = xmlAddPrevSibling (node, (xmlNodePtr) list->data); g_assert (next_node); } g_slist_free (created_nodes); /* destroy @node */ xmlUnlinkNode (node); xmlFreeNode (node); next_node = next_node->next; } else { /* destroy @node */ xmlUnlinkNode (node); xmlFreeNode (node); } if (!cmd_res) return FALSE; } else if (node->children) { if (!real_run_at_node (engine, node->children, context, error)) return FALSE; } } return TRUE; }
void Document::importDocument(Document& other, Node& importNode) { std::lock_guard<std::mutex> lock(_lock); // Locate the top-level node(s) of the other document xml::NodeList topLevelNodes = other.findXPath("/*"); xmlNodePtr targetNode = importNode.getNodePtr(); if (targetNode->name == NULL) { // invalid importnode return; } // greebo: Not all target nodes already have a valid child node, use a modified algorithm // to handle that situation as suggested by malex984 // Add each of the imported nodes to the target importNode for (std::size_t i = 0; i < topLevelNodes.size(); ++i) { if (targetNode->children == NULL) { xmlUnlinkNode(topLevelNodes[i].getNodePtr()); xmlAddChild(targetNode, topLevelNodes[i].getNodePtr()); } else { xmlAddPrevSibling(targetNode->children, topLevelNodes[i].getNodePtr()); } } }
// Node replaceChild(in Node newChild,in Node oldChild) raises(DOMException); static void _replaceChild(Request& r, MethodParams& params) { xmlNode& newChild=as_node(params, 0, "newChild must be node"); xmlNode& oldChild=as_node(params, 1, "oldChild must be node"); VXnode& vnode=GET_SELF(r, VXnode); VXdoc& vxdoc=vnode.get_vxdoc(); xmlDoc& xmldoc=vxdoc.get_xmldoc(); xmlNode& selfNode=vnode.get_xmlnode(); if(newChild.doc!=&xmldoc) throw Exception("xml.dom", 0, "WRONG_DOCUMENT_ERR"); if(oldChild.doc!=&xmldoc) throw Exception("xml.dom", 0, "WRONG_DOCUMENT_ERR"); if(oldChild.parent!=&selfNode) throw Exception("xml.dom", 0, "NOT_FOUND_ERR"); xmlNode* refChild=oldChild.next; xmlUnlinkNode(&oldChild); xmlNode* retNode; if(refChild) retNode=xmlAddPrevSibling(refChild, &newChild); else retNode=xmlAddChild(&selfNode, &newChild); // write out result writeNode(r, vxdoc, retNode); }
void Node::InsertBefore(std::shared_ptr<Node> child) { xmlNodePtr newNode = xmlAddPrevSibling(xml(), child->xml()); if ( newNode == nullptr ) throw InternalError("Unable to add child node", xmlGetLastError()); child->rebind(newNode); }
static BOOL link_datatypes(xmlDocPtr schema) { xmlNodePtr root, next, child; xmlNsPtr ns; assert(xmlGetExternalEntityLoader() == external_entity_loader); root = xmlDocGetRootElement(schema); if (!root) return FALSE; for (ns = root->nsDef; ns != NULL; ns = ns->next) { if (xmlStrEqual(ns->href, DT_nsURI)) break; } if (!ns) return FALSE; next = xmlFirstElementChild(root); child = xmlNewChild(root, NULL, BAD_CAST "import", NULL); if (next) child = xmlAddPrevSibling(next, child); xmlSetProp(child, BAD_CAST "namespace", DT_nsURI); xmlSetProp(child, BAD_CAST "schemaLocation", DT_nsURI); return TRUE; }
bool CSpmXml::AddNode(xmlNodePtr pNode, xmlNodePtr pContext, char nContext) { if (0 == pNode) return false; pContext = GetNode(pContext); if (0 == pContext) return false; xmlNodePtr pCurNode = 0; switch (nContext) { case SPM_XML_CHILD: pCurNode = xmlAddChild(pContext, pNode); break; case SPM_XML_NEXT_SIBLING: pCurNode = xmlAddNextSibling(pContext, pNode); break; case SPM_XML_PREV_SIBLING: pCurNode = xmlAddPrevSibling(pContext, pNode); break; default: return false; } if (0 == pCurNode) return false; m_pCurNode = pCurNode; SetModified(); return true; }
/** * 'insert' operation */ static void edInsert(xmlDocPtr doc, xmlNodeSetPtr nodes, const char *val, const char *name, XmlNodeType type, int mode) { int i; xmlXPathEmptyNodeSet(previous_insertion); for (i = 0; i < nodes->nodeNr; i++) { xmlNodePtr node; if (nodes->nodeTab[i] == (void*) doc && mode != 0) { fprintf(stderr, "The document node cannot have siblings.\n"); exit(EXIT_INTERNAL_ERROR); } /* update node */ if (type == XML_ATTR) { node = (xmlNodePtr) xmlNewProp(nodes->nodeTab[i], BAD_CAST name, BAD_CAST val); } else if (type == XML_ELEM) { node = xmlNewDocNode(doc, NULL /* TODO: NS */, BAD_CAST name, BAD_CAST val); if (mode > 0) xmlAddNextSibling(nodes->nodeTab[i], node); else if (mode < 0) xmlAddPrevSibling(nodes->nodeTab[i], node); else xmlAddChild(nodes->nodeTab[i], node); } else if (type == XML_TEXT) { node = xmlNewDocText(doc, BAD_CAST val); if (mode > 0) xmlAddNextSibling(nodes->nodeTab[i], node); else if (mode < 0) xmlAddPrevSibling(nodes->nodeTab[i], node); else xmlAddChild(nodes->nodeTab[i], node); } xmlXPathNodeSetAdd(previous_insertion, node); } }
// 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; }
/* * Handles incomplete html fragments as may occur on the clipboard, * e.g. a <td> without <tr> and <table> in front of it. */ static void html_search_for_tables (htmlNodePtr cur, htmlDocPtr doc, WorkbookView *wb_view, GnmHtmlTableCtxt *tc) { htmlNodePtr ptr; if (cur == NULL) { xmlGenericError(xmlGenericErrorContext, "htmlNodeDumpFormatOutput : node == NULL\n"); return; } if (cur->type != XML_ELEMENT_NODE) return; if (xmlStrEqual (cur->name, CC2XML ("table"))) { html_read_table (cur, doc, wb_view, tc); } else if (starts_inferred_table (cur) || starts_inferred_row (cur)) { htmlNodePtr tnode = xmlNewNode (NULL, "table"); /* Link in a table node */ xmlAddPrevSibling (cur, tnode); if (starts_inferred_row (cur)) { htmlNodePtr rnode = xmlNewNode (NULL, "tr"); /* Link in a row node */ xmlAddChild (tnode, rnode); /* Make following elements children of the row node, * until we meet one which isn't legal in a row. */ while ((ptr = tnode->next) != NULL) { if (ends_inferred_row (ptr)) break; xmlUnlinkNode (ptr); xmlAddChild (rnode, ptr); } } /* Make following elements children of the row node, * until we meet one which isn't legal in a table. */ while ((ptr = tnode->next) != NULL) { if (ends_inferred_table (ptr)) break; xmlUnlinkNode (ptr); xmlAddChild (tnode, ptr); } html_read_table (tnode, doc, wb_view, tc); } else { for (ptr = cur->children; ptr != NULL ; ptr = ptr->next) { html_search_for_tables (ptr, doc, wb_view, tc); /* ptr may now have been pushed down in the tree, * if so, ptr->next is not the right pointer to * follow */ while (ptr->parent != cur) ptr = ptr->parent; } } }
/* * Class: org_xmlsoft_Node * Method: addPrevSiblingImpl * Signature: (Lrath/libxml/Node;)Lrath/libxml/Node; */ JNIEXPORT jobject JNICALL Java_org_xmlsoft_Node_addPrevSiblingImpl (JNIEnv *env, jobject obj, jobject toAdd) { xmlNode *node = findNode(env, obj); xmlNode *nodeToAdd = findNode(env, toAdd); jobject jdoc = (*env)->GetObjectField(env, obj, fieldNodeDocument); xmlNode *nodeAdded = xmlAddPrevSibling(node, nodeToAdd); jobject ret = buildNode(env, nodeAdded, jdoc); (*env)->DeleteLocalRef(env, jdoc); return ret; }
// Inherits XMLSpy generation source function. xmlNodePtr CNode::InternalInsertAt(ENodeType eNodeType, const tstring& sNamespaceURI, const tstring& sName, int nIndex, const tstring& sValue) { if (eNodeType == Element) return xmlAddPrevSibling( InternalGetAt(eNodeType, sNamespaceURI, sName, nIndex), InternalCreate(eNodeType, sNamespaceURI, sName, sValue) ); else return InternalAppend(eNodeType, sNamespaceURI, sName, sValue); }
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++; }
/* * call-seq: * add_previous_sibling(node) * * Insert +node+ before this node (as a sibling). */ static VALUE add_previous_sibling(VALUE self, VALUE rb_node) { xmlNodePtr node, new_sibling; Data_Get_Struct(self, xmlNode, node); Data_Get_Struct(rb_node, xmlNode, new_sibling); xmlAddPrevSibling(node, new_sibling); rb_funcall(rb_node, rb_intern("decorate!"), 0); return rb_node; }
std::shared_ptr<Element> Node::InsertBefore(const string &name, const string & prefix) { xmlNodePtr child = createChild(name, prefix); xmlNodePtr newNode = xmlAddPrevSibling(xml(), child); if ( newNode == nullptr ) { xmlFreeNode(child); throw InternalError(std::string("Could not add child element node named '") + name.c_str() + "'", xmlGetLastError()); } return Wrapped<Element, _xmlNode>(newNode); }
void savePostXml(char *filename, wppost_t *post) { char xmlfilepath[300]; char dirpath[300]; char *subject; xmlDocPtr doc = xmlParseFile(filename); xmlNodePtr urlNode = getNodeByXpath(doc, (xmlChar *) "/post/url"); xmlNodePtr postIdNode = xmlNewNode (NULL, BAD_CAST "postid"); xmlNodePtr blogIdNode = xmlNewNode (NULL, BAD_CAST "blogid"); xmlNodeSetContent(postIdNode, (xmlChar *) post->postid); xmlNodeSetContent(blogIdNode, (xmlChar *) post->blogid); xmlAddPrevSibling(urlNode, blogIdNode); xmlAddPrevSibling(urlNode, postIdNode); sprintf(dirpath, "%s/%s", getenv("HOME"), WPRESSPATH); mkdir(dirpath, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH); subject = clean_string(post->subject); sprintf(xmlfilepath, "%s/post-%s-%s.xml", dirpath, post->postid, subject); free(subject); xmlSaveFormatFileEnc(xmlfilepath, doc, "UTF-8", 1); printf("Saved as %s\n", xmlfilepath); xmlFreeDoc(doc); }
// Node insertBefore(in Node newChild,in Node refChild) raises(DOMException); static void _insertBefore(Request& r, MethodParams& params) { xmlNode& newChild=as_node(params, 0, "newChild must be node"); xmlNode& refChild=as_node(params, 1, "refChild must be node"); VXnode& vnode=GET_SELF(r, VXnode); VXdoc& vxdoc=vnode.get_vxdoc(); //xmlNode& selfNode=vnode.get_xmlnode(); xmlNode* retNode=xmlAddPrevSibling(&refChild, &newChild); // write out result writeNode(r, vxdoc, retNode); }
/* ############################################################################# * * Description add a DTD to the xml document * Author Harry Brueckner * Date 2005-05-04 * Arguments SHOWERROR_FN - callback function for error messages * Return -1 if the DTD could not be updated, 0 if the document did not * validate and 1 if everything is ok */ int checkDtd(SHOWERROR_FN showerror_cb) { xmlDtd* dtd; xmlParserInputBuffer* inputbuffer; xmlValidCtxt* context = xmlNewValidCtxt(); char* dtdbuffer; TRACE(99, "checkDtd()", NULL); if (!xmldoc) { return -1; } xmlRemoveDtd(); /* first we create the DTD as a whole */ dtdbuffer = memAlloc(__FILE__, __LINE__, strlen(dtd_1) + strlen(dtd_2) + strlen(dtd_3) + 1); if (!dtdbuffer) { return -1; } strStrncpy(dtdbuffer, dtd_1, strlen(dtd_1) + 1); strStrncat(dtdbuffer, dtd_2, strlen(dtd_2) + 1); strStrncat(dtdbuffer, dtd_3, strlen(dtd_3) + 1); /* create the xml buffer */ inputbuffer = xmlParserInputBufferCreateMem(dtdbuffer, strlen(dtdbuffer), XML_CHAR_ENCODING_8859_1); memFreeString(__FILE__, __LINE__, dtdbuffer); if (!dtdbuffer) { return -1; } /* and finally create the DTD */ dtd = xmlIOParseDTD(NULL, inputbuffer, XML_CHAR_ENCODING_8859_1); if (!dtd) { return -1; } /* and attach the DTD to the document */ if (!xmldoc -> children) { xmlAddChild((xmlNode*)xmldoc, (xmlNode*)dtd); } else { xmlAddPrevSibling(xmldoc -> children, (xmlNode*)dtd); } /* we set our own error handler */ validateShowError = showerror_cb; context -> error = xmlValidateError; context -> warning = xmlValidateWarning; return xmlValidateDtd(context, xmldoc, dtd); }
static void ngx_http_xslt_sax_external_subset(void *data, const xmlChar *name, const xmlChar *externalId, const xmlChar *systemId) { xmlParserCtxtPtr ctxt = data; xmlDocPtr doc; xmlDtdPtr dtd; ngx_http_request_t *r; ngx_http_xslt_filter_ctx_t *ctx; ngx_http_xslt_filter_loc_conf_t *conf; ctx = ctxt->sax->_private; r = ctx->request; conf = ngx_http_get_module_loc_conf(r, ngx_http_xslt_filter_module); ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "xslt filter extSubset: \"%s\" \"%s\" \"%s\"", name ? name : (xmlChar *) "", externalId ? externalId : (xmlChar *) "", systemId ? systemId : (xmlChar *) ""); doc = ctxt->myDoc; #if (NGX_HTTP_XSLT_REUSE_DTD) dtd = conf->dtd; #else dtd = xmlCopyDtd(conf->dtd); if (dtd == NULL) { ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "xmlCopyDtd() failed"); return; } if (doc->children == NULL) { xmlAddChild((xmlNodePtr) doc, (xmlNodePtr) dtd); } else { xmlAddPrevSibling(doc->children, (xmlNodePtr) dtd); } #endif doc->extSubset = dtd; }
/*AddChild - creates new child element tname - name of new child element tcontent - value of new child element telement - on success, points to new child element returns False on error. */ Bool CXMLElement::AddChild(char *tname, char *tcontent,CXMLElement *telement, bool tbefore) { if (!isinited()) return False; xmlNodePtr newchild = xmlNewTextChild(element, NULL, (xmlChar *)tname, (xmlChar *)tcontent); if (newchild) { if (tbefore) xmlAddPrevSibling(element -> children, newchild); if (telement) telement->SetNodePtr(newchild); } return newchild != NULL; }
// Inherits XMLSpy generation source function. void CNode::InternalSetElementValue(const tstring& sValue) { xmlNodePtr pTextNode = xmlNewDocText(m_pDOMNode->doc, X(sValue)); xmlNodePtr pChild = m_pDOMNode->children; if(pChild) { if(pChild->type == XML_TEXT_NODE) { xmlReplaceNode(pChild, pTextNode); xmlFreeNode(pChild); } else { xmlAddPrevSibling(pChild, pTextNode); } } else { xmlAddChild(m_pDOMNode, pTextNode); } }
/* * call-seq: * node.prev = node * * Insert the specified node as this node's previous sibling. */ static VALUE rxml_node_prev_set(VALUE self, VALUE rnode) { xmlNodePtr cnode, pnode, ret; if (rb_obj_is_kind_of(rnode, cXMLNode) == Qfalse) rb_raise(rb_eTypeError, "Must pass an XML::Node object"); Data_Get_Struct(self, xmlNode, pnode); Data_Get_Struct(rnode, xmlNode, cnode); ret = xmlAddPrevSibling(pnode, cnode); if (ret == NULL) rxml_raise(&xmlLastError); return (rxml_node_wrap(cXMLNode, ret)); }
int main() { xmlDocPtr doc; xmlNodePtr racine, premier_prod, nouv_prod; // Ouverture du fichier XML xmlKeepBlanksDefault(0); doc = xmlParseFile("catalogue.xml"); if (doc == NULL) { fprintf(stderr, "Document XML invalide\n"); return EXIT_FAILURE; } // Récupération de la racine racine = xmlDocGetRootElement(doc); if (racine == NULL) { fprintf(stderr, "Document XML vierge\n"); xmlFreeDoc(doc); return EXIT_FAILURE; } // Récupération du premier produit premier_prod = obtenir_premier_produit(doc); if (premier_prod == NULL) { fprintf(stderr, "Impossible de trouver le premier produit\n"); xmlFreeDoc(doc); return EXIT_FAILURE; } // Ajout d'un nouveau produit avant le premier produit (en tête) nouv_prod = creer_produit("CD0YAH", "Autocollant Developpez.com", "0.80"); if (nouv_prod) { xmlAddPrevSibling(premier_prod, nouv_prod); } // Ajout d'un nouveau produit après le premier produit nouv_prod = creer_produit("U0TZ6K", "Lot de 10 autocollants Developpez.com", "5.00"); if (nouv_prod) { xmlAddNextSibling(premier_prod, nouv_prod); } // Ajout d'un nouveau produit en fin/queue nouv_prod = creer_produit("ZQEYAN", "Mug Developpez.com", "4.00"); if (nouv_prod) { xmlAddSibling(premier_prod, nouv_prod); } // Affichage de l'arbre DOM tel qu'il est en mémoire xmlDocFormatDump(stdout, doc, 1); // Libération de la mémoire xmlFreeDoc(doc); return EXIT_SUCCESS; }
void Document::importDocument(Document& other, Node& importNode) { // Locate the top-level node(s) of the other document xml::NodeList topLevelNodes = other.findXPath("/*"); xmlNodePtr targetNode = importNode.getNodePtr(); if (targetNode->children == NULL || targetNode->name == NULL) { // invalid importnode return; } // Add each of the imported nodes to the target importNode for (std::size_t i = 0; i < topLevelNodes.size(); i++) { xmlAddPrevSibling(targetNode->children, topLevelNodes[i].getNodePtr()); } }