Java Document.importNode方法代码示例

import org.w3c.dom.Document; //导入方法依赖的package包/类
private void addChildNodes(Document xmlDocument, Node parent,
						   List<Node> nodes) {
	Node copiedNode;
	for (int i = 0; i < nodes.size(); i++) {
		copiedNode = xmlDocument.importNode(nodes.get(i), true);
		parent.appendChild(copiedNode);
	}
}
 

import org.w3c.dom.Document; //导入方法依赖的package包/类
static protected void createCopy(Step step, Document doc, Element stepNode) throws EngineException {
	NodeList list = step.getContextValues();
	if (list != null) {
		int len = list.getLength();
		for (int i=0; i<len;i++) {
			Node node = list.item(i);
			if (node != null) {
				boolean shouldImport = !node.getOwnerDocument().equals(doc);
				Node child = shouldImport ? doc.importNode(node, true):node.cloneNode(true);
				if (child.getNodeType() == Node.ELEMENT_NODE) {
					stepNode.appendChild((Element) child);
				} else if (child.getNodeType() == Node.ATTRIBUTE_NODE) {
					stepNode.setAttribute(child.getNodeName(),child.getNodeValue());
				}
			}
		}
	}
}
 

import org.w3c.dom.Document; //导入方法依赖的package包/类
private static Element cloneSafely(Element el) { // #190845
    // #50198: for thread safety, use a separate document.
    // Using XMLUtil.createDocument is much too slow.
    synchronized (db) {
        Document dummy = db.newDocument();
        return (Element) dummy.importNode(el, true);
    }
}
 

import org.w3c.dom.Document; //导入方法依赖的package包/类
private static Element cloneSafely(Element el) {
    // #50198: for thread safety, use a separate document.
    // Using XMLUtil.createDocument is much too slow.
    synchronized (db) {
        Document dummy = db.newDocument();
        return (Element) dummy.importNode(el, true);
    }
}
 

import org.w3c.dom.Document; //导入方法依赖的package包/类
public Element getConfigurationFragment(String elementName, String namespace, boolean shared) {
    Element el = find(shared, namespace, elementName);

    if (el != null) {
        Document dummy = XMLUtil.createDocument("test", null, null, null);
        return (Element) dummy.importNode(el, true);
    }
    
    return null;
}
 

import org.w3c.dom.Document; //导入方法依赖的package包/类
private Document getXpathData(Document document, String xPath) {
	if (document == null) {
		return null;
	}
	if (xPath == null) {
		return null;
	}

	try {
		Document doc = XMLUtils.getDefaultDocumentBuilder().newDocument();
		Element root =  (Element) doc.createElement("root"); 
		doc.appendChild(root);
		
		NodeList nl = getXpathApi().selectNodeList(document, xPath);
		if (nl != null)
			for (int i = 0; i< nl.getLength(); i++) {
				Node node = doc.importNode(nl.item(i), true);
				Element elt = doc.getDocumentElement();
				if (node.getNodeType() == Node.ELEMENT_NODE) {
					elt.appendChild(node);
				}
				if (node.getNodeType() == Node.TEXT_NODE) {
					elt.appendChild(node);
				}
				if (node.getNodeType() == Node.ATTRIBUTE_NODE) {
					elt.setAttribute(node.getNodeName() + "_" + i, node.getNodeValue());
				}
			}

		return doc;
	} catch (TransformerException e) {
		ConvertigoPlugin.logWarning("Error for xpath : '" + xPath + "'\r " + e.getMessage());
		return null;
	}
}
 

import org.w3c.dom.Document; //导入方法依赖的package包/类
public static void setByPath(Document doc, String path, Node in) {
    if (in.getNodeType() == Node.DOCUMENT_NODE) {
        in = in.getFirstChild();
    }
    Node node = getNodeByPath(doc, path, true);
    if (node == null) {
        throw new RuntimeException("no results for xpath: " + path);
    }
    Node newNode = doc.importNode(in, true);
    if (node.hasChildNodes() && node.getFirstChild().getNodeType() == Node.TEXT_NODE) {
        node.replaceChild(newNode, node.getFirstChild());
    } else {
        node.appendChild(newNode);
    }
}
 

import org.w3c.dom.Document; //导入方法依赖的package包/类
/**
 * Given the target Node, return the DocumentFragment, imported into the
 * target Document
 * @param targetNode 
 */
protected final DocumentFragment getImportedComponentFragment(Node targetNode)
{
  Document targetDocument = targetNode.getOwnerDocument();
  
  // return a deep import
  return (DocumentFragment)targetDocument.importNode(_fragment, true);
}
 

import org.w3c.dom.Document; //导入方法依赖的package包/类
protected Element importElement(Element element) {
    Document document = getOwnerDocument();
    Document oldDocument = element.getOwnerDocument();
    if (!oldDocument.equals(document)) {
        return (Element) document.importNode(element, true);
    } else {
        return element;
    }
}
 

import org.w3c.dom.Document; //导入方法依赖的package包/类
private  SOAPElement convertToSoapElement(Element element) throws SOAPException {

        if (element instanceof SOAPElement) {
            return (SOAPElement) element;
        }

        SOAPElement copy = createElement(
                                element.getLocalName(),
                                element.getPrefix(),
                                element.getNamespaceURI());

        Document ownerDoc = copy.getOwnerDocument();

        NamedNodeMap attrMap = element.getAttributes();
        for (int i=0; i < attrMap.getLength(); i++) {
            Attr nextAttr = (Attr)attrMap.item(i);
            Attr importedAttr = (Attr)ownerDoc.importNode(nextAttr, true);
            copy.setAttributeNodeNS(importedAttr);
        }


        NodeList nl = element.getChildNodes();
        for (int i=0; i < nl.getLength(); i++) {
            org.w3c.dom.Node next = nl.item(i);
            org.w3c.dom.Node imported = ownerDoc.importNode(next, true);
            copy.appendChild(imported);
        }

        return copy;
    }
 

import org.w3c.dom.Document; //导入方法依赖的package包/类
private synchronized void writeToDOM(Node target, short type) {
    Document futureOwner = (type == XSAnnotation.W3C_DOM_ELEMENT) ?
            target.getOwnerDocument() : (Document)target;
    DOMParser parser = fGrammar.getDOMParser();
    StringReader aReader = new StringReader(fData);
    InputSource aSource = new InputSource(aReader);
    try {
        parser.parse(aSource);
    }
    catch (SAXException e) {
        // this should never happen!
        // REVISIT:  what to do with this?; should really not
        // eat it...
    }
    catch (IOException i) {
        // ditto with above
    }
    Document aDocument = parser.getDocument();
    parser.dropDocumentReferences();
    Element annotation = aDocument.getDocumentElement();
    Node newElem = null;
    if (futureOwner instanceof CoreDocumentImpl) {
        newElem = futureOwner.adoptNode(annotation);
        // adoptNode will return null when the DOM implementations are not compatible.
        if (newElem == null) {
            newElem = futureOwner.importNode(annotation, true);
        }
    }
    else {
        newElem = futureOwner.importNode(annotation, true);
    }
    target.insertBefore(newElem, target.getFirstChild());
}
 

import org.w3c.dom.Document; //导入方法依赖的package包/类
private static void copyNodeWithoutNamespace(Document document, Node parentNode, Node sourceNode) {
	Node destinationNode;
	if (sourceNode instanceof Document) {
		destinationNode = parentNode;
	} else {
		if (sourceNode instanceof Element) {
			String localName = XMLUtils.getLocalName(sourceNode);
			destinationNode = document.createElement(localName);
			
			// Copy attributes
			NamedNodeMap attributes = sourceNode.getAttributes();
			for (int i = 0; i < attributes.getLength(); i++) {
				Node sourceAttribute = attributes.item(i);
				
				String prefix = XMLUtils.getPrefix(sourceAttribute);
				
				if (!prefix.equalsIgnoreCase("xmlns")) {
					((Element) destinationNode).setAttribute(XMLUtils.getLocalName(sourceAttribute),
							sourceAttribute.getNodeValue());
				}
			}
		} else {
			destinationNode = document.importNode(sourceNode, false);
		}
		
		parentNode.appendChild(destinationNode);
	}
	
	NodeList childNodes = sourceNode.getChildNodes();
	int len = childNodes.getLength();
	for (int i = 0; i < len; i++) {
		XMLUtils.copyNodeWithoutNamespace(document, destinationNode, childNodes.item(i));
	}
}
 

import org.w3c.dom.Document; //导入方法依赖的package包/类
private void createStepNodeSingleValue(Document doc, Element stepNode, String key, Object value) {
	if (value instanceof NativeJavaObject) {
		value = ((NativeJavaObject) value).unwrap();
	}
	if (value instanceof XMLVector) {
		XMLVector<Object> nodeValues = GenericUtils.cast(value);
		for (Object object : nodeValues) {
			createStepNodeSingleValue(doc, stepNode, key, object);
		}
	} else if (value.getClass().isArray()) {
		int len = Array.getLength(value);
		for (int i = 0; i < len ; i++) {
			createStepNodeSingleValue(doc, stepNode, key, Array.get(value, i));
		}
	} else {
		Element var = doc.createElement(key.toString());
		stepNode.appendChild(var);

		// Structured variable
		if (value instanceof NodeList) {
			NodeList valueNodeList = (NodeList) value;
			int nlLen = valueNodeList.getLength();
			Document document = stepNode.getOwnerDocument();
			for (int i = 0; i < nlLen; i++) {
				Node nodeVarPart = valueNodeList.item(i);
				if (!nodeVarPart.getOwnerDocument().equals(document))
					nodeVarPart = document.importNode(nodeVarPart, true);
				var.appendChild(nodeVarPart);
			}
		} else {
			String nodeValue = value.toString();
			Node text = doc.createTextNode(nodeValue);
			var.appendChild(text);
		}
	}
}
 

import org.w3c.dom.Document; //导入方法依赖的package包/类
public Map<Integer, Dependency> processDTree(Node dTree){
	Map<Integer, Dependency> dep = new HashMap<Integer, Dependency>();
	// Tuple to position mapping
	Map<String, Integer> tupleMap = new HashMap<String, Integer>();
	// here starts the hard part
	try {
		Document D = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
		Node initialTree = D.importNode(dTree.getLastChild().getFirstChild(), true);
		D.appendChild(initialTree);
        //rebuild tree nodes
        NodeList treeNodes = D.getElementsByTagName("tree");
        ArrayList<Node> tNodes = new ArrayList<Node>();            
        for (int l = 0; l < treeNodes.getLength(); l++)
        {
            tNodes.add(treeNodes.item(l));    
        }
        for (int i = 0; i < tNodes.size(); i++)
        {
            Node treeNode = tNodes.get(i);
            String treeid = treeNode.getAttributes().getNamedItem("id").getNodeValue();
            TagTree tree  = subgrammar.get(treeid);
            int posi = this.getPosition(tree, tupleMap);
            // we process the "local" dependencies, ie co-anchors or lexical items
            this.getPositionsForTree(tree, posi, dep);
            
            if (treeNode.getParentNode().getParentNode() != null) {
            	// ie it is not the root node
            	// we retrieve the operation's Gorn address
                String opNode = treeNode.getParentNode().getAttributes().getNamedItem("node").getNodeValue();	                
            	// we retrieve the parent
                String parent = treeNode.getParentNode().getParentNode().getAttributes().getNamedItem("id").getNodeValue();
                //System.err.println(treeid + " --> " + parent);
                TagTree ptree = subgrammar.get(parent);
                // we retrieve the node cat:
                List<de.tuebingen.tree.Node> ln = new LinkedList<de.tuebingen.tree.Node>();
                ptree.findNode(ptree.getRoot(), opNode, ln);
                TagNode n  = ln.size() > 0 ? (TagNode) ln.get(0) : null;
                String cat = "";
                if (n != null) {
                	cat = n.getCategory();
                }
                int parentPosi = this.getPosition(ptree, tupleMap);
                if (parentPosi != posi && tree.getIsHead()) {
                	//System.err.println(" Dependency detected " + posi + " " + parentPosi);
                	dep.put(posi, new Dependency(parentPosi, cat));
                }
            } else {
            	// otherwise
            	//System.err.println(" Dependency detected " + posi + " " + 0);
            	dep.put(posi, new Dependency(0, "ROOT"));
            }
        }
	} catch (ParserConfigurationException e){
           System.err.println("Error while extracting dependencies: ");
           System.err.println(e.toString());
           StackTraceElement[] stack = e.getStackTrace();
           for (int i = 0; i < stack.length; i++)
           {
               System.err.println(stack[i]);
           }
	}
	//System.err.println(" ------ " );
	return dep;
}
 

import org.w3c.dom.Document; //导入方法依赖的package包/类
public void displayTargetWsdlDom(DatabaseObject dbo) {
	try {
		if (dbo instanceof Step) {
			Step step = (Step)dbo;
			String xpath = getSourceXPath();
			String anchor = step.getAnchor();
			Document stepDoc = null;
			
			Step targetStep = step;
			while (targetStep instanceof IteratorStep) {
				targetStep = getTargetStep(targetStep);
			}
			
			if (targetStep != null) {
				Project project = step.getProject();
				XmlSchema schema = Engine.theApp.schemaManager.getSchemaForProject(project.getName(), Option.fullSchema);
				XmlSchemaObject xso = SchemaMeta.getXmlSchemaObject(schema, targetStep);
				if (xso != null) {
					stepDoc = XmlSchemaUtils.getDomInstance(xso);	
				}
			}
			
			if (stepDoc != null/* && !(targetStep instanceof IteratorStep)*/) { // stepDoc can be null for non "xml" step : e.g jIf
				Document doc = step.getSequence().createDOM();
				Element root = (Element)doc.importNode(stepDoc.getDocumentElement(), true);
				doc.replaceChild(root, doc.getDocumentElement());
				removeUserDefinedNodes(doc.getDocumentElement());
				boolean shouldDisplayDom = (!(!step.isXml() && (step instanceof StepWithExpressions) && !(step instanceof IteratorStep)));
				if ((doc != null) && (shouldDisplayDom)) {
					xpath = onDisplayXhtml(xpath);
					displayXhtml(doc);
					xpathEvaluator.removeAnchor();
					xpathEvaluator.displaySelectionXpathWithAnchor(twsDomTree, anchor, xpath);
					return;
				}
			}
		}
	} catch (Exception e) {
		ConvertigoPlugin.logException(e, StringUtils.readStackTraceCauses(e));
	}
	clean();
}