bundles/org.eclipse.wst.xml.core/src/org/eclipse/wst/xml/core/internal/document/NodeIteratorImpl.java - sourceediting/webtools.sourceediting - Git at Google

 /*******************************************************************************
  * Copyright (c) 2001, 2004 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *     Jens Lukowski/Innoopract - initial renaming/restructuring
  *
  *******************************************************************************/
 package org.eclipse.wst.xml.core.internal.document;


 import org.w3c.dom.DOMException;
 import org.w3c.dom.Node;
 import org.w3c.dom.traversal.NodeFilter;
 import org.w3c.dom.traversal.NodeIterator;

 /**
  * NodeIteratorImpl class
  */
 public class NodeIteratorImpl implements NodeIterator {
 	private NodeFilter filter = null;
 	private Node nextNode = null;

 	private Node rootNode = null;
 	private int whatToShow = NodeFilter.SHOW_ALL;

 	/**
 	 * NodeIteratorImpl constructor
 	 *
 	 * @param rootNode
 	 *            org.w3c.dom.Node
 	 */
 	NodeIteratorImpl(Node rootNode, int whatToShow, NodeFilter filter) {
 		this.rootNode = rootNode;
 		this.nextNode = rootNode;
 		this.whatToShow = whatToShow;
 		this.filter = filter;
 	}

 	/**
 	 */
 	private final boolean acceptNode(Node node) {
 		if (this.whatToShow != NodeFilter.SHOW_ALL) {
 			if (node == null)
 				return false;
 			short nodeType = node.getNodeType();
 			switch (this.whatToShow) {
 				case NodeFilter.SHOW_ELEMENT :
 					if (nodeType != Node.ELEMENT_NODE)
 						return false;
 					break;
 				case NodeFilter.SHOW_ATTRIBUTE :
 					if (nodeType != Node.ATTRIBUTE_NODE)
 						return false;
 					break;
 				case NodeFilter.SHOW_TEXT :
 					if (nodeType != Node.TEXT_NODE)
 						return false;
 					break;
 				case NodeFilter.SHOW_CDATA_SECTION :
 					if (nodeType != Node.CDATA_SECTION_NODE)
 						return false;
 					break;
 				case NodeFilter.SHOW_ENTITY_REFERENCE :
 					if (nodeType != Node.ENTITY_REFERENCE_NODE)
 						return false;
 					break;
 				case NodeFilter.SHOW_ENTITY :
 					if (nodeType != Node.ENTITY_NODE)
 						return false;
 					break;
 				case NodeFilter.SHOW_PROCESSING_INSTRUCTION :
 					if (nodeType != Node.PROCESSING_INSTRUCTION_NODE)
 						return false;
 					break;
 				case NodeFilter.SHOW_COMMENT :
 					if (nodeType != Node.COMMENT_NODE)
 						return false;
 					break;
 				case NodeFilter.SHOW_DOCUMENT :
 					if (nodeType != Node.DOCUMENT_NODE)
 						return false;
 					break;
 				case NodeFilter.SHOW_DOCUMENT_TYPE :
 					if (nodeType != Node.DOCUMENT_TYPE_NODE)
 						return false;
 					break;
 				case NodeFilter.SHOW_DOCUMENT_FRAGMENT :
 					if (nodeType != Node.DOCUMENT_FRAGMENT_NODE)
 						return false;
 					break;
 				case NodeFilter.SHOW_NOTATION :
 					if (nodeType != Node.NOTATION_NODE)
 						return false;
 					break;
 				default :
 					return false;
 			}
 		}
 		if (this.filter != null) {
 			return (this.filter.acceptNode(node) == NodeFilter.FILTER_ACCEPT);
 		}
 		return true;
 	}

 	/**
 	 * Detaches the <code>NodeIterator</code> from the set which it iterated
 	 * over, releasing any computational resources and placing the iterator in
 	 * the INVALID state. After <code>detach</code> has been invoked, calls
 	 * to <code>nextNode</code> or <code>previousNode</code> will raise
 	 * the exception INVALID_STATE_ERR.
 	 */
 	public void detach() {
 		this.rootNode = null;
 		this.nextNode = null;
 		this.filter = null;
 	}

 	/**
 	 * The value of this flag determines whether the children of entity
 	 * reference nodes are visible to the iterator. If false, they and their
 	 * descendants will be rejected. Note that this rejection takes precedence
 	 * over <code>whatToShow</code> and the filter. Also note that this is
 	 * currently the only situation where <code>NodeIterators</code> may
 	 * reject a complete subtree rather than skipping individual nodes. <br>
 	 * <br>
 	 * To produce a view of the document that has entity references expanded
 	 * and does not expose the entity reference node itself, use the
 	 * <code>whatToShow</code> flags to hide the entity reference node and
 	 * set <code>expandEntityReferences</code> to true when creating the
 	 * iterator. To produce a view of the document that has entity reference
 	 * nodes but no entity expansion, use the <code>whatToShow</code> flags
 	 * to show the entity reference node and set
 	 * <code>expandEntityReferences</code> to false.
 	 */
 	public boolean getExpandEntityReferences() {
 		// not supported
 		return false;
 	}

 	/**
 	 * The <code>NodeFilter</code> used to screen nodes.
 	 */
 	public NodeFilter getFilter() {
 		return this.filter;
 	}

 	/**
 	 */
 	private final Node getNextNode() {
 		if (this.nextNode == null)
 			return null;
 		Node oldNext = this.nextNode;
 		Node child = this.nextNode.getFirstChild();
 		if (child != null) {
 			this.nextNode = child;
 			return oldNext;
 		}
 		for (Node node = this.nextNode; node != null && node != this.rootNode; node = node.getParentNode()) {
 			Node next = node.getNextSibling();
 			if (next != null) {
 				this.nextNode = next;
 				return oldNext;
 			}
 		}
 		this.nextNode = null;
 		return oldNext;
 	}

 	/**
 	 */
 	private final Node getPreviousNode() {
 		if (this.nextNode == this.rootNode)
 			return null;
 		Node prev = null;
 		if (this.nextNode == null) {
 			prev = this.rootNode; // never null
 		} else {
 			prev = this.nextNode.getPreviousSibling();
 			if (prev == null) {
 				this.nextNode = this.nextNode.getParentNode();
 				return this.nextNode;
 			}
 		}
 		Node last = prev.getLastChild();
 		while (last != null) {
 			prev = last;
 			last = prev.getLastChild();
 		}
 		this.nextNode = prev;
 		return this.nextNode;
 	}

 	/**
 	 * The root node of the <code>NodeIterator</code>, as specified when it
 	 * was created.
 	 */
 	public Node getRoot() {
 		return this.rootNode;
 	}

 	/**
 	 * This attribute determines which node types are presented via the
 	 * iterator. The available set of constants is defined in the
 	 * <code>NodeFilter</code> interface. Nodes not accepted by
 	 * <code>whatToShow</code> will be skipped, but their children may still
 	 * be considered. Note that this skip takes precedence over the filter, if
 	 * any.
 	 */
 	public int getWhatToShow() {
 		return this.whatToShow;
 	}

 	/**
 	 * Returns the next node in the set and advances the position of the
 	 * iterator in the set. After a <code>NodeIterator</code> is created,
 	 * the first call to <code>nextNode()</code> returns the first node in
 	 * the set.
 	 *
 	 * @return The next <code>Node</code> in the set being iterated over, or
 	 *         <code>null</code> if there are no more members in that set.
 	 * @exception DOMException
 	 *                INVALID_STATE_ERR: Raised if this method is called after
 	 *                the <code>detach</code> method was invoked.
 	 */
 	public Node nextNode() throws DOMException {
 		for (Node node = getNextNode(); node != null; node = getNextNode()) {
 			if (acceptNode(node))
 				return node;
 		}
 		return null;
 	}

 	/**
 	 * Returns the previous node in the set and moves the position of the
 	 * <code>NodeIterator</code> backwards in the set.
 	 *
 	 * @return The previous <code>Node</code> in the set being iterated
 	 *         over, or <code>null</code> if there are no more members in
 	 *         that set.
 	 * @exception DOMException
 	 *                INVALID_STATE_ERR: Raised if this method is called after
 	 *                the <code>detach</code> method was invoked.
 	 */
 	public Node previousNode() throws DOMException {
 		for (Node node = getPreviousNode(); node != null; node = getPreviousNode()) {
 			if (acceptNode(node))
 				return node;
 		}
 		return null;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2001, 2004 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	* Jens Lukowski/Innoopract - initial renaming/restructuring
	*
	*******************************************************************************/
	package org.eclipse.wst.xml.core.internal.document;



	import org.w3c.dom.DOMException;
	import org.w3c.dom.Node;
	import org.w3c.dom.traversal.NodeFilter;
	import org.w3c.dom.traversal.NodeIterator;

	/**
	* NodeIteratorImpl class
	*/
	public class NodeIteratorImpl implements NodeIterator {
	private NodeFilter filter = null;
	private Node nextNode = null;

	private Node rootNode = null;
	private int whatToShow = NodeFilter.SHOW_ALL;

	/**
	* NodeIteratorImpl constructor
	*
	* @param rootNode
	* org.w3c.dom.Node
	*/
	NodeIteratorImpl(Node rootNode, int whatToShow, NodeFilter filter) {
	this.rootNode = rootNode;
	this.nextNode = rootNode;
	this.whatToShow = whatToShow;
	this.filter = filter;
	}

	/**
	*/
	private final boolean acceptNode(Node node) {
	if (this.whatToShow != NodeFilter.SHOW_ALL) {
	if (node == null)
	return false;
	short nodeType = node.getNodeType();
	switch (this.whatToShow) {
	case NodeFilter.SHOW_ELEMENT :
	if (nodeType != Node.ELEMENT_NODE)
	return false;
	break;
	case NodeFilter.SHOW_ATTRIBUTE :
	if (nodeType != Node.ATTRIBUTE_NODE)
	return false;
	break;
	case NodeFilter.SHOW_TEXT :
	if (nodeType != Node.TEXT_NODE)
	return false;
	break;
	case NodeFilter.SHOW_CDATA_SECTION :
	if (nodeType != Node.CDATA_SECTION_NODE)
	return false;
	break;
	case NodeFilter.SHOW_ENTITY_REFERENCE :
	if (nodeType != Node.ENTITY_REFERENCE_NODE)
	return false;
	break;
	case NodeFilter.SHOW_ENTITY :
	if (nodeType != Node.ENTITY_NODE)
	return false;
	break;
	case NodeFilter.SHOW_PROCESSING_INSTRUCTION :
	if (nodeType != Node.PROCESSING_INSTRUCTION_NODE)
	return false;
	break;
	case NodeFilter.SHOW_COMMENT :
	if (nodeType != Node.COMMENT_NODE)
	return false;
	break;
	case NodeFilter.SHOW_DOCUMENT :
	if (nodeType != Node.DOCUMENT_NODE)
	return false;
	break;
	case NodeFilter.SHOW_DOCUMENT_TYPE :
	if (nodeType != Node.DOCUMENT_TYPE_NODE)
	return false;
	break;
	case NodeFilter.SHOW_DOCUMENT_FRAGMENT :
	if (nodeType != Node.DOCUMENT_FRAGMENT_NODE)
	return false;
	break;
	case NodeFilter.SHOW_NOTATION :
	if (nodeType != Node.NOTATION_NODE)
	return false;
	break;
	default :
	return false;
	}
	}
	if (this.filter != null) {
	return (this.filter.acceptNode(node) == NodeFilter.FILTER_ACCEPT);
	}
	return true;
	}

	/**
	* Detaches the <code>NodeIterator</code> from the set which it iterated
	* over, releasing any computational resources and placing the iterator in
	* the INVALID state. After <code>detach</code> has been invoked, calls
	* to <code>nextNode</code> or <code>previousNode</code> will raise
	* the exception INVALID_STATE_ERR.
	*/
	public void detach() {
	this.rootNode = null;
	this.nextNode = null;
	this.filter = null;
	}

	/**
	* The value of this flag determines whether the children of entity
	* reference nodes are visible to the iterator. If false, they and their
	* descendants will be rejected. Note that this rejection takes precedence
	* over <code>whatToShow</code> and the filter. Also note that this is
	* currently the only situation where <code>NodeIterators</code> may
	* reject a complete subtree rather than skipping individual nodes. <br>
	* <br>
	* To produce a view of the document that has entity references expanded
	* and does not expose the entity reference node itself, use the
	* <code>whatToShow</code> flags to hide the entity reference node and
	* set <code>expandEntityReferences</code> to true when creating the
	* iterator. To produce a view of the document that has entity reference
	* nodes but no entity expansion, use the <code>whatToShow</code> flags
	* to show the entity reference node and set
	* <code>expandEntityReferences</code> to false.
	*/
	public boolean getExpandEntityReferences() {
	// not supported
	return false;
	}

	/**
	* The <code>NodeFilter</code> used to screen nodes.
	*/
	public NodeFilter getFilter() {
	return this.filter;
	}

	/**
	*/
	private final Node getNextNode() {
	if (this.nextNode == null)
	return null;
	Node oldNext = this.nextNode;
	Node child = this.nextNode.getFirstChild();
	if (child != null) {
	this.nextNode = child;
	return oldNext;
	}
	for (Node node = this.nextNode; node != null && node != this.rootNode; node = node.getParentNode()) {
	Node next = node.getNextSibling();
	if (next != null) {
	this.nextNode = next;
	return oldNext;
	}
	}
	this.nextNode = null;
	return oldNext;
	}

	/**
	*/
	private final Node getPreviousNode() {
	if (this.nextNode == this.rootNode)
	return null;
	Node prev = null;
	if (this.nextNode == null) {
	prev = this.rootNode; // never null
	} else {
	prev = this.nextNode.getPreviousSibling();
	if (prev == null) {
	this.nextNode = this.nextNode.getParentNode();
	return this.nextNode;
	}
	}
	Node last = prev.getLastChild();
	while (last != null) {
	prev = last;
	last = prev.getLastChild();
	}
	this.nextNode = prev;
	return this.nextNode;
	}

	/**
	* The root node of the <code>NodeIterator</code>, as specified when it
	* was created.
	*/
	public Node getRoot() {
	return this.rootNode;
	}

	/**
	* This attribute determines which node types are presented via the
	* iterator. The available set of constants is defined in the
	* <code>NodeFilter</code> interface. Nodes not accepted by
	* <code>whatToShow</code> will be skipped, but their children may still
	* be considered. Note that this skip takes precedence over the filter, if
	* any.
	*/
	public int getWhatToShow() {
	return this.whatToShow;
	}

	/**
	* Returns the next node in the set and advances the position of the
	* iterator in the set. After a <code>NodeIterator</code> is created,
	* the first call to <code>nextNode()</code> returns the first node in
	* the set.
	*
	* @return The next <code>Node</code> in the set being iterated over, or
	* <code>null</code> if there are no more members in that set.
	* @exception DOMException
	* INVALID_STATE_ERR: Raised if this method is called after
	* the <code>detach</code> method was invoked.
	*/
	public Node nextNode() throws DOMException {
	for (Node node = getNextNode(); node != null; node = getNextNode()) {
	if (acceptNode(node))
	return node;
	}
	return null;
	}

	/**
	* Returns the previous node in the set and moves the position of the
	* <code>NodeIterator</code> backwards in the set.
	*
	* @return The previous <code>Node</code> in the set being iterated
	* over, or <code>null</code> if there are no more members in
	* that set.
	* @exception DOMException
	* INVALID_STATE_ERR: Raised if this method is called after
	* the <code>detach</code> method was invoked.
	*/
	public Node previousNode() throws DOMException {
	for (Node node = getPreviousNode(); node != null; node = getPreviousNode()) {
	if (acceptNode(node))
	return node;
	}
	return null;
	}
	}