Java TreeWalker.setCurrentNode方法代码示例

import org.w3c.dom.traversal.TreeWalker; //导入方法依赖的package包/类
private static void traverseLevel(TreeWalker walker, Element topParent, String indent) {
    // describe current node:
    Element current = (Element) walker.getCurrentNode();
    //System.out.println(indent + "- " + ((Element) current).getTagName());
    
    // store elements which need to be moved
    if (topParent != null) {
    	Element parent = (Element) current.getParentNode();
    	if (parent != null && !topParent.equals(parent)) {
    	    OutputFilter outputFilter = (OutputFilter)walker.getFilter();
    		outputFilter.getToAddList(topParent).add(current);
    	}
    }
    
    // traverse children:
    for (Node n = walker.firstChild(); n != null; n = walker.nextSibling()) {
      traverseLevel(walker, current, indent + '\t');
    }
    
    // return position to the current (level up):
    walker.setCurrentNode(current);
}
 

import org.w3c.dom.traversal.TreeWalker; //导入方法依赖的package包/类
private List<Feature> parseTree(TreeWalker walker,
                                String tag,
                                String chr,
                                List<Feature> features) {

    Node parent = walker.getCurrentNode();
    Element n = (Element) walker.firstChild();
    while (n != null) {
        if (n.getTagName().equalsIgnoreCase(tag)) {
            Feature f = getFeature(walker, chr);
            if (f != null) {
                features.add(f);
            }

            n = (Element) walker.nextSibling();
            continue;
        }
        parseTree(walker, tag, chr, features);
        n = (Element) walker.nextSibling();
    }
    walker.setCurrentNode(parent);
    return features;
}
 

import org.w3c.dom.traversal.TreeWalker; //导入方法依赖的package包/类
private void setPackageToElements(TreeWalker tw, String currentPackage) {
    Node n = tw.getCurrentNode();
    XmiElement element = new XmiElement((Element) n, this);
    if (isPackageElement(element)) {
        if (currentPackage.isEmpty()) {
            currentPackage = element.getNameTag();
        } else {
            currentPackage = currentPackage + XmiTags.SEPARATOR + element.getNameTag();
        }
        logger.debug("Current package has changed " + currentPackage);
    } else if (elementIdMap.get(element.getXmiId()) != null) {
        elementIdMap.get(element.getXmiId()).setPackageContainer(currentPackage);
    }
    for (Node child = tw.firstChild();
        child != null;
        child = tw.nextSibling()) {
        setPackageToElements(tw, currentPackage);
    }
    tw.setCurrentNode(n);
}
 

import org.w3c.dom.traversal.TreeWalker; //导入方法依赖的package包/类
private static int traverseLevel(TreeWalker walker, int counter) {
	// describe current node:
	final Node parend = walker.getCurrentNode();

	if (parend instanceof Element) {
		if (((Element) parend).getAttribute("id").length() == 0) {
			((Element) parend).setAttribute("id", "gen-id-" + counter);
			counter++;
		}
	}

	// traverse children:
	for (Node n = walker.firstChild(); n != null; n = walker.nextSibling()) {
		counter = traverseLevel(walker, counter);
	}

	// return position to the current (level up):
	walker.setCurrentNode(parend);

	return counter;
}
 

import org.w3c.dom.traversal.TreeWalker; //导入方法依赖的package包/类
public static boolean hasChildElement(TreeWalker walker)
{
    Node current = walker.getCurrentNode();
    Node child = walker.firstChild();
    if (child != null)
    {
        walker.setCurrentNode(current);
        return true;
    }
    return false;
}
 

import org.w3c.dom.traversal.TreeWalker; //导入方法依赖的package包/类
private void fillElementIdMap(TreeWalker tw) {
    Node n = tw.getCurrentNode();
    Element element = (Element) n;
    if (element.getAttributeNode(XmiTags.XMI_ID_TAG) != null) {
        XmiElement xmiElement = new XmiElement(element, this);
        elementIdMap.put(xmiElement.getXmiId(), xmiElement);
        //System.out.println("entity "+xmiElement.getNameTag()+" type "+xmiElement.getXmiType());
    }
    for (Node child = tw.firstChild();
        child != null;
        child = tw.nextSibling()) {
        fillElementIdMap(tw);
    }
    tw.setCurrentNode(n);
}
 

import org.w3c.dom.traversal.TreeWalker; //导入方法依赖的package包/类
protected void getArticleTextMapping(TreeWalker walker, List<MappingNode> map) throws DOMException {
	final Node parend = walker.getCurrentNode();

	if (parend.getNodeType() == Node.TEXT_NODE && parend.getParentNode().getAttributes().getNamedItem("id") != null)
	{
		if (parend.getTextContent().trim().length() > 0)
		{
			final int index = findChildNodeIndex(parend.getParentNode(), parend);
			if (index != -1)
			{
				// square brackets are not valid XML/HTML identifier
				// characters, so we can use them here
				map.add(new MappingNode(
						parend.getParentNode().getAttributes().getNamedItem("id").getNodeValue() + "[" + index + "]",
						parend.getNodeValue()));

				// System.out.println(
				// "ELEMENT '"+parend.getParentNode().getAttributes().getNamedItem("id").getNodeValue()
				// + "["+index+"]"+"'");
				// System.out.println( "VALUE:  '"+parend.getNodeValue()+"'"
				// );
			}
		}
	}

	// traverse children:
	for (Node n = walker.firstChild(); n != null; n = walker.nextSibling()) {
		getArticleTextMapping(walker, map);
	}

	// return position to the current (level up):
	walker.setCurrentNode(parend);
}
 

import org.w3c.dom.traversal.TreeWalker; //导入方法依赖的package包/类
public static boolean isFirstOfItsKindIn(Node node, Node ancestor) {
	if (ancestor == null)
		return false;
	Document doc = node.getOwnerDocument();
	if (doc == null)
		return false;
	TreeWalker tw = ((DocumentTraversal) doc).createTreeWalker(doc, NodeFilter.SHOW_ALL,
			new NameNodeFilter(node.getNodeName()), true);
	tw.setCurrentNode(node);
	Node prev = tw.previousNode();

	return prev == null || // no node with same name before this one
			!isAncestor(ancestor, prev); // prev is not in the same ancestor
}
 

import org.w3c.dom.traversal.TreeWalker; //导入方法依赖的package包/类
public static boolean isLastOfItsKindIn(Node node, Node ancestor) {
	if (node == null || ancestor == null)
		return false;
	Document doc = node.getOwnerDocument();
	if (doc == null)
		return false;
	TreeWalker tw = ((DocumentTraversal) doc).createTreeWalker(doc, NodeFilter.SHOW_ALL,
			new NameNodeFilter(node.getNodeName()), true);
	tw.setCurrentNode(node);
	Node next = tw.nextNode();

	return next == null || // no node with same name after this one
			!isAncestor(ancestor, next); // next is not in the same ancestor
}
 

import org.w3c.dom.traversal.TreeWalker; //导入方法依赖的package包/类
/**
 * Find the Element with the same tag name as <code>element</code> preceding <code>element</code> within the same subtree
 * under <code>root</code>. Precondition: <code>root</code> must be an ancestor of <code>element</code>.
 * 
 * @param element
 *            element
 * @param root
 *            root
 * @return that Element, or <code>null</code> if there is no such Element.
 */
public static Element getPreviousOfItsKindIn(Element element, Element root) {
	if (element == null || root == null)
		return null;
	String tagname = element.getTagName();
	TreeWalker tw = ((DocumentTraversal) element.getOwnerDocument()).createTreeWalker(root, NodeFilter.SHOW_ELEMENT,
			new NameNodeFilter(tagname), true);
	tw.setCurrentNode(element);
	for (Node previous = tw.previousNode(); previous != null; previous = tw.previousNode()) {
		if (previous.getNodeName().equals(tagname)) {
			return (Element) previous;
		}
	}
	return null;
}
 

import org.w3c.dom.traversal.TreeWalker; //导入方法依赖的package包/类
/**
 * Find the Element with the same tag name as <code>element</code> following <code>element</code> within the same subtree
 * under <code>root</code>. Precondition: <code>root</code> must be an ancestor of <code>element</code>.
 * 
 * @param element
 *            element
 * @param root
 *            root
 * @return that Element, or <code>null</code> if there is no such Element.
 */
public static Element getNextOfItsKindIn(Element element, Element root) {
	if (element == null || root == null)
		return null;
	String tagname = element.getTagName();
	TreeWalker tw = ((DocumentTraversal) element.getOwnerDocument()).createTreeWalker(root, NodeFilter.SHOW_ELEMENT,
			new NameNodeFilter(tagname), true);
	tw.setCurrentNode(element);
	for (Node next = tw.nextNode(); next != null; next = tw.nextNode()) {
		if (next.getNodeName().equals(tagname)) {
			return (Element) next;
		}
	}
	return null;
}
 

import org.w3c.dom.traversal.TreeWalker; //导入方法依赖的package包/类
protected boolean matchSelector(CombinedSelector sel, Element e, TreeWalker w) {

		// store current walker position
		Node current = w.getCurrentNode();

		boolean retval = false;
		Selector.Combinator combinator = null;
		// traverse simple selector backwards
		for (int i = sel.size() - 1; i >= 0; i--) {
			// last simple selector
			Selector s = sel.get(i);
			//log.trace("Iterating loop with selector {}, combinator {}",	s, combinator);

			// decide according to combinator anti-pattern
			if (combinator == null) {
				retval = s.matches(e);
			} else if (combinator == Selector.Combinator.ADJACENT) {
				Element adjacent = (Element) w.previousSibling();
				retval = false;
				if (adjacent != null)
					retval = s.matches(adjacent);
            } else if (combinator == Selector.Combinator.PRECEDING) {
                Element preceding;
                retval = false;
                while (!retval && (preceding = (Element) w.previousSibling()) != null) {
                    retval = s.matches(preceding);
                }
			} else if (combinator == Selector.Combinator.DESCENDANT) {
                Element ancestor;
                retval = false;
                while (!retval && (ancestor = (Element) w.parentNode()) != null) {
                    retval = s.matches(ancestor);
                }
			} else if (combinator == Selector.Combinator.CHILD) {
                Element parent = (Element) w.parentNode();
                retval = false;
                if (parent != null)
                    retval = s.matches(parent);
			}

			// set combinator for next loop
			combinator = s.getCombinator();

			// leave loop if not matched
			if (retval == false)
				break;
		}

		// restore walker position
		w.setCurrentNode(current);
		return retval;
	}
 

import org.w3c.dom.traversal.TreeWalker; //导入方法依赖的package包/类
protected boolean matchSelector(CombinedSelector sel, Element e, TreeWalker w) {

		// store current walker position
		Node current = w.getCurrentNode();

		boolean retval = false;
		Selector.Combinator combinator = null;
		// traverse simple selector backwards
		for (int i = sel.size() - 1; i >= 0; i--) {
			// last simple selector
			Selector s = sel.get(i);
			//log.trace("Iterating loop with selector {}, combinator {}",	s, combinator);

			// decide according to combinator anti-pattern
			if (combinator == null) {
				retval = this.elementSelectorMatches(s, e);
			} else if (combinator == Selector.Combinator.ADJACENT) {
				Element adjacent = (Element) w.previousSibling();
				retval = false;
				if (adjacent != null)
					retval = this.elementSelectorMatches(s, adjacent);
            } else if (combinator == Selector.Combinator.PRECEDING) {
                Element preceding;
                retval = false;
                while (!retval && (preceding = (Element) w.previousSibling()) != null) {
                    retval = this.elementSelectorMatches(s, preceding);
                }
			} else if (combinator == Selector.Combinator.DESCENDANT) {
                Element ancestor;
                retval = false;
                while (!retval && (ancestor = (Element) w.parentNode()) != null) {
                    retval = this.elementSelectorMatches(s, ancestor);
                }
			} else if (combinator == Selector.Combinator.CHILD) {
                Element parent = (Element) w.parentNode();
                retval = false;
                if (parent != null)
                    retval = this.elementSelectorMatches(s, parent);
			}

			// set combinator for next loop
			combinator = s.getCombinator();

			// leave loop if not matched
			if (!retval)
				break;
		}

		// restore walker position
		w.setCurrentNode(current);
		return retval;
	}